home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 24 / Amiga Format AFCD24 (Feb 1998, Issue 108).iso / -in_the_mag- / emulation / macos / uae069b2.src.cpt.hqx / UAE069ß2.SRC.CPT / uae069fl2.src / custom.c < prev    next >
C/C++ Source or Header  |  1997-07-04  |  169KB  |  5,698 lines
  1.  /*
  2.   * UAE - The Un*x Amiga Emulator
  3.   * 
  4.   * Custom chip emulation
  5.   * 
  6.   * Copyright 1995, 1996, 1997 Bernd Schmidt
  7.   * Copyright 1995 Alessandro Bissacco
  8.   */
  9.  
  10. #include "sysconfig.h"
  11. #include "sysdeps.h"
  12.  
  13. #include <ctype.h>
  14. #include <assert.h>
  15.  
  16. #include "config.h"
  17. #include "options.h"
  18. #include "gensound.h"
  19. #include "sounddep/sound.h"
  20. #include "events.h"
  21. #include "uae.h"
  22. #include "my_memory.h"
  23. #include "custom.h"
  24. #include "readcpu.h"
  25. #include "newcpu.h"
  26. #include "cia.h"
  27. #include "disk.h"
  28. #include "blitter.h"
  29. #include "xwin.h"
  30. #include "joystick.h"
  31. #include "audio.h"
  32. #include "keybuf.h"
  33. #include "serial.h"
  34. #include "osemu.h"
  35. #include "autoconf.h"
  36. #include "threaddep/penguin.h"
  37.  
  38. #ifdef X86_ASSEMBLY
  39. #define LORES_HACK
  40. #endif
  41. #define SPRITE_COLLISIONS
  42.  
  43. /*
  44.  * Several people have tried this define, with not much success. Turning on
  45.  * AGA garbles the screen. A place you could start looking is the calcdiw()
  46.  * function - the AGA timing parameters are different, and apparently I
  47.  * haven't figured out the correct formula yet. Pity, the current one looks
  48.  * logical.
  49.  * 
  50.  * @@@ Probably won't compile in this version.
  51.  */
  52.  
  53. /* #define EMULATE_AGA */
  54.  
  55. #ifndef EMULATE_AGA
  56. #define AGA_CHIPSET 0
  57. #else
  58. #define AGA_CHIPSET 1
  59. #endif
  60.  
  61. #define SMART_UPDATE 1
  62.  
  63. #ifdef SUPPORT_PENGUINS
  64. #undef SMART_UPDATE
  65. #define SMART_UPDATE 1
  66. #endif
  67.  
  68. #if AGA_CHIPSET == 1
  69. #define MAX_PLANES 8
  70. #else
  71. #define MAX_PLANES 6
  72. #endif
  73.  
  74. /* Fetched data spends 9 lores pixels somewhere in the chips before it appears
  75.  * on-screen. We don't emulate this. Instead, we cheat with the copper to
  76.  * compensate (much easier that way). */
  77. #define COPPER_MAGIC_FUDGE -9
  78. /* We ignore that many lores pixels at the start of the display. These are
  79.  * invisible anyway due to hardware DDF limits. */
  80. #define DISPLAY_LEFT_SHIFT 0x38
  81. static int lores_factor, lores_shift, sprite_width;
  82.  
  83. #define PIXEL_XPOS(HPOS) (((HPOS)*2 - DISPLAY_LEFT_SHIFT) << lores_shift)
  84.  
  85. /* @@@ Is maxhpos + 4 - 1 correct? (4 less isn't enough) */
  86. #define max_diwlastword (PIXEL_XPOS(maxhpos + 4 -1))
  87.  
  88. /* These are default values for mouse calibration.
  89.  * The first two are default values for mstepx and mstepy.
  90.  * The second line set the horizontal and vertical offset for amiga and X 
  91.  * pointer matching
  92.  */
  93.  
  94. #define defstepx (1<<16)
  95. #define defstepy (1<<16)
  96. #define defxoffs 0
  97. #define defyoffs 0
  98.     
  99. /* Values below define mouse auto calibration process.
  100.  * They are not critical, change them if you want.
  101.  * The most important is calweight, which sets mouse adjustement rate */ 
  102.  
  103. static const int docal = 60, xcaloff = 40, ycaloff = 20;
  104. static const int calweight = 3;
  105. static int lastsampledmx, lastsampledmy;
  106.  
  107.  /*
  108.   * Events
  109.   */
  110.  
  111. unsigned long int cycles, nextevent, is_lastline, did_reset;
  112. struct ev eventtab[ev_max];
  113.  
  114. frame_time_t vsynctime, vsyncmintime;
  115.  
  116. int vpos;
  117. uae_u16 lof;
  118. static int lof_changed = 0, interlace_seen = 0;
  119.  
  120. static int copper_waiting_for_blitter, copper_active;
  121. static const int dskdelay = 2; /* FIXME: ??? */
  122.  
  123. static int dblpf_ind1[256], dblpf_ind2[256], dblpf_2nd1[256], dblpf_2nd2[256];
  124. static int dblpf_aga1[256], dblpf_aga2[256], linear_map_256[256], lots_of_twos[256];
  125.  
  126. static int dblpfofs[] = { 0, 2, 4, 8, 16, 32, 64, 128 };
  127.  
  128. /*
  129.  * Big lookup tables
  130.  */
  131.  
  132. static uae_u32 hirestab_h[256][2];
  133. static uae_u32 lorestab_h[256][4];
  134.  
  135. static uae_u32 hirestab_l[256][1];
  136. static uae_u32 lorestab_l[256][2];
  137.  
  138. static uae_u32 sprtaba[256],sprtabb[256];
  139. static uae_u32 clxtab[256];
  140.  
  141.  
  142. /*
  143.  * Hardware registers of all sorts.
  144.  */
  145.  
  146. static int fmode;
  147.  
  148. static uae_u16 cregs[256];
  149.  
  150. uae_u16 intena,intreq;
  151. uae_u16 dmacon;
  152. uae_u16 adkcon; /* used by audio code */
  153.  
  154. static uae_u32 cop1lc,cop2lc,copcon;
  155.  
  156. /* This is but an educated guess. It seems to be correct, but this stuff
  157.  * isn't documented well. */
  158. enum sprstate { SPR_stop, SPR_restart, SPR_waiting_start, SPR_waiting_stop };
  159. static enum sprstate sprst[8];
  160. static int spron[8];
  161. static uaecptr sprpt[8];
  162. static int sprxpos[8], sprvstart[8], sprvstop[8];
  163.  
  164. static uae_u32 bpl1dat,bpl2dat,bpl3dat,bpl4dat,bpl5dat,bpl6dat,bpl7dat,bpl8dat;
  165. static uae_s16  bpl1mod,bpl2mod;
  166.  
  167. static uaecptr bplpt[8];
  168. #ifndef SMART_UPDATE
  169. static char *real_bplpt[8];
  170. #endif
  171.  
  172. /*static int blitcount[256];  blitter debug */
  173.  
  174. struct color_entry {
  175. #if AGA_CHIPSET == 0
  176.     /* X86.S expects this at the start of the structure. */
  177.     xcolnr acolors[32];
  178.     uae_u16 color_regs[32];
  179. #else
  180.     uae_u32 color_regs[256];
  181. #endif
  182. };
  183.  
  184. static struct color_entry current_colors;
  185. struct color_entry colors_for_drawing;
  186. static unsigned int bplcon0,bplcon1,bplcon2,bplcon3,bplcon4;
  187. static int nr_planes_from_bplcon0, corrected_nr_planes_from_bplcon0;
  188. static unsigned int diwstrt,diwstop,ddfstrt,ddfstop;
  189. static unsigned int sprdata[8], sprdatb[8], sprctl[8], sprpos[8];
  190. static int sprarmed[8], sprite_last_drawn_at[8];
  191. static int last_sprite_point, nr_armed;
  192. static uae_u16 clxdat, clxcon;
  193. static int clx_sprmask;
  194. static uae_u32 dskpt;
  195. static uae_u16 dsklen,dsksync;
  196.  
  197. static int mouse_x, mouse_y;
  198. int joy0button, joy1button;
  199. unsigned int joy0dir, joy1dir;
  200. static int lastspr0x,lastspr0y,lastdiffx,lastdiffy,spr0pos,spr0ctl;
  201. static int mstepx,mstepy,xoffs=defxoffs,yoffs=defyoffs;
  202. static int sprvbfl;
  203.  
  204. static enum { normal_mouse, dont_care_mouse, follow_mouse } mousestate;
  205. static int ievent_alive = 0;
  206. static uae_u32 coplc;
  207. static unsigned int copi1,copi2;
  208.  
  209. static enum copper_states {
  210.     COP_stop, COP_read, COP_do_read, COP_read_ignore, COP_do_read_ignore, COP_wait, COP_morewait, COP_move, COP_skip
  211. } copstate;
  212. /* The time the copper needs for one cycle depends on bitplane DMA. Whenever
  213.  * possible, we calculate a fixed value and store it here. */
  214. static int copper_cycle_time;
  215.  
  216. static int dsklength;
  217.  
  218. static int plffirstline,plflastline,plfstrt,plfstop,plflinelen;
  219. static int diwfirstword,diwlastword;
  220. static enum { DIW_waiting_start, DIW_waiting_stop } diwstate, hdiwstate;
  221.  
  222. int dskdmaen; /* used in cia.c */
  223.  
  224. /* 880 isn't a magic number, it's a safe number with some padding at the end.
  225.  * This used to be 1000, but that's excessive. (840 is too low). I'm too lazy
  226.  * to figure out the exact space needed. */
  227. union {
  228.     /* Let's try to align this thing. */
  229.     double uupzuq;
  230.     long int cruxmedo;
  231.     unsigned char apixels[880];
  232. } pixdata;
  233.  
  234. uae_u32 ham_linebuf[880];
  235. uae_u32 aga_linebuf[880], *aga_lbufptr;
  236.  
  237. char *xlinebuffer;
  238. int next_lineno;
  239. static int nln_how;
  240.  
  241. static int *amiga2aspect_line_map, *native2amiga_line_map;
  242. static char **row_map;
  243. static int max_drawn_amiga_line;
  244.  
  245. /*
  246.  * Statistics
  247.  */
  248.  
  249. /* Used also by bebox.cpp */
  250. unsigned long int msecs = 0, frametime = 0, timeframes = 0;
  251. static unsigned long int seconds_base;
  252. int bogusframe;
  253.  
  254. /*
  255.  * helper functions
  256.  */
  257.  
  258. int inhibit_frame;
  259. static int framecnt = 0;
  260. static int frame_redraw_necessary;
  261. static unsigned long n_frame_count;        //xxx ATB
  262. static unsigned long m_timera,m_timerb; //xxx ATB
  263. unsigned long m_FPS;                     //xxx ATB
  264. extern int showFPS;                        //xxx ATB
  265. static __inline__ void count_frame(void)
  266. {
  267.     framecnt++;
  268. //xxx ATB    
  269.     n_frame_count++;
  270.     if (n_frame_count==50)
  271.     { if (showFPS) {
  272.         m_timera=TickCount();
  273.         m_FPS=3000/((double)(m_timera-m_timerb));
  274.         m_timerb=m_timera;
  275.         n_frame_count=0;
  276.         }
  277.     }
  278.     if (framecnt >= currprefs.framerate)
  279.     framecnt = 0;
  280. }
  281.  
  282. static __inline__ void setclr(uae_u16 *p, uae_u16 val)
  283. {
  284.     if (val & 0x8000) {
  285.     *p |= val & 0x7FFF;
  286.     } else {
  287.     *p &= ~val;
  288.     }
  289. }
  290.  
  291. __inline__ int current_hpos(void)
  292. {
  293.     return cycles - eventtab[ev_hsync].oldcycles;
  294. }
  295.  
  296. static __inline__ uae_u8 *pfield_xlateptr(uaecptr plpt, int bytecount)
  297. {
  298.     if (!chipmem_bank.check(plpt,bytecount)) {
  299.     static int count = 0;
  300.     if (!count)
  301.         count++, write_log ("Warning: Bad playfield pointer\n");
  302.     return NULL;
  303.     }
  304.     return chipmem_bank.xlateaddr(plpt);
  305. }
  306.  
  307. static void calculate_copper_cycle_time (void)
  308. {
  309.     if (diwstate == DIW_waiting_start || !dmaen (DMA_BITPLANE)) {
  310.     copper_cycle_time = 2;
  311.     return;
  312.     }
  313.     copper_cycle_time = corrected_nr_planes_from_bplcon0 <= 4 ? 2 : -1;
  314. }
  315.  
  316. struct vidbuf_description gfxvidinfo;
  317.  
  318. /* line_draw_funcs: pfield_do_linetoscr, pfield_do_fill_line, decode_ham6 */
  319. typedef void (*line_draw_func)(int, int);
  320.  
  321. #define LINE_UNDECIDED 1
  322. #define LINE_DECIDED 2
  323. #define LINE_DECIDED_DOUBLE 3
  324. #define LINE_AS_PREVIOUS 4
  325. #define LINE_BORDER_NEXT 5
  326. #define LINE_BORDER_PREV 6
  327. #define LINE_DONE 7
  328. #define LINE_DONE_AS_PREVIOUS 8
  329. #define LINE_REMEMBERED_AS_PREVIOUS 9
  330.  
  331. static char *line_drawn;
  332. static char linestate[(maxvpos + 1)*2 + 1];
  333.  
  334. static int min_diwstart, max_diwstop, prev_x_adjust, linetoscr_x_adjust, linetoscr_right_x;
  335. static int linetoscr_x_adjust_bytes;
  336. static int thisframe_y_adjust, prev_y_adjust, thisframe_first_drawn_line, thisframe_last_drawn_line;
  337. static int thisframe_y_adjust_real, max_ypos_thisframe, min_ypos_for_screen;
  338. static int extra_y_adjust;
  339.  
  340. /* 50 words give you 800 horizontal pixels. An A500 can't do that, so it ought
  341.  * to be enough. */
  342. #define MAX_WORDS_PER_LINE 50
  343. static uae_u8 line_data[(maxvpos+1) * 2][MAX_PLANES * MAX_WORDS_PER_LINE * 2];
  344.  
  345. /*
  346.  * The idea behind this code is that at some point during each horizontal
  347.  * line, we decide how to draw this line. There are many more-or-less
  348.  * independent decisions, each of which can be taken at a different horizontal
  349.  * position.
  350.  * Sprites, color changes and bitplane delay changes are handled specially: 
  351.  * There isn't a single decision, but a list of structures containing 
  352.  * information on how to draw the line.
  353.  */
  354.  
  355. struct color_change {
  356.     int linepos;
  357.     int regno;
  358.     unsigned long value;
  359. };
  360.  
  361. struct sprite_draw {
  362.     int linepos;
  363.     int num;
  364.     int ctl;
  365.     uae_u32 datab;
  366. };
  367.  
  368. struct delay_change {
  369.     int linepos;
  370.     unsigned int value;
  371. };
  372.  
  373. /* Way too much... */
  374. #define MAX_REG_CHANGE ((maxvpos+1) * 2 * maxhpos)
  375. static int current_change_set;
  376.  
  377. #ifdef OS_WITHOUT_MEMORY_MANAGEMENT
  378. /* sam: Those arrays uses around 7Mb of BSS... That seems  */
  379. /* too much for AmigaDOS (uae crashes as soon as one loads */
  380. /* it. So I use a different strategy here (realloc the     */
  381. /* arrays when needed. That strategy might be usefull for  */
  382. /* computer with low memory.                               */
  383. static struct sprite_draw  *sprite_positions[2];
  384. static int max_sprite_draw    = 400;
  385. static int delta_sprite_draw  = 0;
  386. static struct color_change *color_changes[2];
  387. static int max_color_change   = 400;
  388. static int delta_color_change = 0;
  389. static struct delay_change *delay_changes;
  390. static int max_delay_change = 100;
  391. static int delta_delay_change = 0;
  392. #else
  393. static struct sprite_draw sprite_positions[2][MAX_REG_CHANGE];
  394. static struct color_change color_changes[2][MAX_REG_CHANGE];
  395. /* We don't remember those across frames, that would be too much effort. 
  396.  * We simply redraw the line whenever we see one of these. */
  397. static struct delay_change delay_changes[MAX_REG_CHANGE];
  398. #endif
  399. static struct sprite_draw *curr_sprite_positions, *prev_sprite_positions;
  400. static struct color_change *curr_color_changes, *prev_color_changes;
  401.  
  402. static int next_color_change, next_sprite_draw, next_delay_change;
  403.  
  404. static struct color_entry color_tables[2][(maxvpos+1) * 2];
  405. static struct color_entry *curr_color_tables, *prev_color_tables;
  406. static int next_color_entry, remembered_color_entry, drawing_color_matches;
  407. static enum { color_match_acolors, color_match_full } color_match_type;
  408. static int color_src_match, color_dest_match, color_compare_result;
  409.  
  410. static int last_redraw_point;
  411.  
  412. static int first_drawn_line, last_drawn_line;
  413. static int first_block_line, last_block_line;
  414.  
  415. static __inline__ void docols(struct color_entry *colentry)
  416. {
  417. #if AGA_CHIPSET == 0
  418.     int i;
  419.     for (i = 0; i < 32; i++)
  420.     colentry->acolors[i] = xcolors[colentry->color_regs[i]];
  421. #endif
  422. }
  423.  
  424. void notice_new_xcolors (void)
  425. {
  426.     int i;
  427.     docols(¤t_colors);
  428.     docols(&colors_for_drawing);
  429.     for (i = 0; i < (maxvpos+1)*2; i++) {
  430.     docols(color_tables[0]+i);
  431.     docols(color_tables[1]+i);
  432.     }
  433. }
  434.  
  435. void notice_screen_contents_lost (void)
  436. {
  437.     frame_redraw_necessary = 2;
  438. }
  439.  
  440. static void init_regchanges (void)
  441. {
  442.     size_t i;
  443.  
  444.     next_color_change = 0;
  445.     next_sprite_draw = 0;
  446.     current_change_set = 0;
  447.     for (i = 0; i < sizeof linestate / sizeof *linestate; i++)
  448.     linestate[i] = LINE_UNDECIDED;
  449. }
  450.  
  451. /* struct decision contains things we save across drawing frames for
  452.  * comparison (smart update stuff). */
  453. struct decision {
  454.     unsigned long color0;
  455.     int which;
  456.     int plfstrt, plflinelen;
  457.     int diwfirstword, diwlastword;
  458.     int ctable;
  459.  
  460.     uae_u16 bplcon0, bplcon1, bplcon2;
  461. #if 0 /* We don't need this. */
  462.     uae_u16 bplcon3;
  463. #endif
  464. #if AGA_CHIPSET == 1
  465.     uae_u16 bplcon4;
  466. #endif
  467. };
  468.  
  469. /* Anything related to changes in hw registers during the DDF for one
  470.  * line. */
  471. struct draw_info {
  472.     int first_sprite_draw, last_sprite_draw;
  473.     int first_color_change, last_color_change;
  474.     int first_delay_change, last_delay_change;
  475.     int nr_color_changes, nr_sprites;
  476. };
  477.  
  478. /* These few are only needed during/at the end of the scanline, and don't
  479.  * have to be remembered. */
  480. static int decided_bpl1mod, decided_bpl2mod, decided_nr_planes, decided_hires;
  481.  
  482. /* These are generated by the drawing code from the line_decisions array for
  483.  * each line that needs to be drawn. */
  484. static int bplehb, bplham, bpldualpf, bpldualpfpri, bplplanecnt, bplhires;
  485. static int bpldelay1, bpldelay2;
  486. static int plfpri[3];
  487.  
  488. static struct decision line_decisions[2 * (maxvpos+1) + 1];
  489. static struct draw_info line_drawinfo[2][2 * (maxvpos+1) + 1];
  490. static struct draw_info *curr_drawinfo, *prev_drawinfo;
  491. static struct decision *dp_for_drawing;
  492. static struct draw_info *dip_for_drawing;
  493.  
  494. static char line_changed[2 * (maxvpos+1)];
  495.  
  496. #ifdef SMART_UPDATE
  497. #define MARK_LINE_CHANGED(l) do { line_changed[l] = 1; } while (0)
  498. #else
  499. #define MARK_LINE_CHANGED(l) do { } while (0)
  500. #endif
  501.  
  502. static struct decision thisline_decision;
  503. static int modulos_added, plane_decided, color_decided, very_broken_program;
  504.  
  505. static void do_sprites(int currvp, int currhp);
  506.  
  507. static void remember_ctable (void)
  508. {
  509.     if (remembered_color_entry == -1) {
  510.     /* The colors changed since we last recorded a color map. Record a
  511.      * new one. */
  512.     memcpy (curr_color_tables + next_color_entry, ¤t_colors, sizeof current_colors);
  513.     remembered_color_entry = next_color_entry++;
  514.     }
  515.     thisline_decision.ctable = remembered_color_entry;
  516.     if (color_src_match == -1 || color_dest_match != remembered_color_entry
  517.     || line_decisions[next_lineno].ctable != color_src_match)
  518.     {
  519.     /* The remembered comparison didn't help us - need to compare again. */
  520.     int oldctable = line_decisions[next_lineno].ctable;
  521.     int changed = 0;
  522.  
  523.     if (oldctable == -1) {
  524.         changed = 1;
  525.         color_src_match = color_dest_match = -1;
  526.     } else {
  527.         color_compare_result = fast_memcmp (&prev_color_tables[oldctable].color_regs, 
  528.                         ¤t_colors.color_regs,
  529.                         sizeof current_colors.color_regs) != 0;
  530.         if (color_compare_result)
  531.         changed = 1;
  532.         color_src_match = oldctable;
  533.         color_dest_match = remembered_color_entry;
  534.     }
  535.     if (changed) {
  536.         line_changed[next_lineno] = 1;
  537.     }
  538.     } else {
  539.     /* We know the result of the comparison */
  540.     if (color_compare_result)
  541.         line_changed[next_lineno] = 1;
  542.     }
  543. }
  544.  
  545. static void remember_ctable_for_border (void)
  546. {
  547.     remember_ctable ();
  548. #if 0
  549.     if (remembered_color_entry == -1) {
  550.     /* The colors changed since we last recorded a color map. Record a
  551.      * new one. */
  552.     memcpy (curr_color_tables + next_color_entry, ¤t_colors, sizeof current_colors);
  553.     remembered_color_entry = next_color_entry++;
  554.     }
  555.     thisline_decision.ctable = remembered_color_entry;
  556.     if (color_src_match == -1 || color_dest_match != remembered_color_entry
  557.     || line_decisions[next_lineno].ctable != color_src_match)
  558.     {
  559.     /* The remembered comparison didn't help us - need to compare again. */
  560.     int oldctable = line_decisions[next_lineno].ctable;
  561.     int changed = 0;
  562.  
  563.     if (oldctable == -1) {
  564.         changed = 1;
  565.         color_src_match = color_dest_match = -1;
  566.     } else {
  567.         color_compare_result = fast_memcmp (&prev_color_tables[oldctable].color_regs, 
  568.                         ¤t_colors.color_regs,
  569.                         sizeof current_colors.color_regs) != 0;
  570.         if (color_compare_result)
  571.         changed = 1;
  572.         color_src_match = oldctable;
  573.         color_dest_match = remembered_color_entry;
  574.     }
  575.     if (changed) {
  576.         line_changed[next_lineno] = 1;
  577.     }
  578.     } else {
  579.     /* We know the result of the comparison */
  580.     if (color_compare_result)
  581.         line_changed[next_lineno] = 1;
  582.     }
  583. #endif
  584. }
  585.  
  586. static void decide_diw (void)
  587. {
  588.     if (hdiwstate == DIW_waiting_start && thisline_decision.diwfirstword == -1
  589.     && PIXEL_XPOS (current_hpos ()) >= diwfirstword) 
  590.     {
  591.     thisline_decision.diwfirstword = diwfirstword;
  592.     hdiwstate = DIW_waiting_stop;
  593.     /* Decide playfield delays only at DIW start, because they don't matter before and
  594.      * some programs change them after DDF start but before DIW start. */
  595.     thisline_decision.bplcon1 = bplcon1;
  596.     if (thisline_decision.diwfirstword != line_decisions[next_lineno].diwfirstword)
  597.         MARK_LINE_CHANGED (next_lineno);
  598.     thisline_decision.diwlastword = -1;
  599.     }
  600.     if (hdiwstate == DIW_waiting_stop && thisline_decision.diwlastword == -1 
  601.     && PIXEL_XPOS (current_hpos ()) >= diwlastword)
  602.     {
  603.     thisline_decision.diwlastword = diwlastword;
  604.     hdiwstate = DIW_waiting_start;
  605.     if (thisline_decision.diwlastword != line_decisions[next_lineno].diwlastword)
  606.         MARK_LINE_CHANGED (next_lineno);
  607.     }
  608. }
  609.  
  610. static __inline__ void decide_as_playfield (int startpos, int len)
  611. {
  612.     thisline_decision.which = 1;
  613.  
  614.     /* The latter condition might be able to happen in interlaced frames. */
  615.     if (vpos >= minfirstline && (thisframe_first_drawn_line == -1 || vpos < thisframe_first_drawn_line))
  616.     thisframe_first_drawn_line = vpos;
  617.     thisframe_last_drawn_line = vpos;
  618.  
  619.     thisline_decision.plfstrt = startpos;
  620.     thisline_decision.plflinelen = len;
  621.  
  622.     /* These are for comparison. */
  623.     thisline_decision.bplcon0 = bplcon0;
  624.     thisline_decision.bplcon2 = bplcon2;
  625. #if AGA_CHIPSET == 1
  626.     thisline_decision.bplcon4 = bplcon4;
  627. #endif
  628.  
  629. #ifdef SMART_UPDATE
  630.     if (line_decisions[next_lineno].plfstrt != thisline_decision.plfstrt
  631.     || line_decisions[next_lineno].plflinelen != thisline_decision.plflinelen
  632.     || line_decisions[next_lineno].bplcon0 != thisline_decision.bplcon0
  633.     || line_decisions[next_lineno].bplcon2 != thisline_decision.bplcon2
  634. #if AGA_CHIPSET == 1
  635.     || line_decisions[next_lineno].bplcon4 != thisline_decision.bplcon4
  636. #endif
  637.     )
  638. #endif /* SMART_UPDATE */
  639.     line_changed[next_lineno] = 1;
  640. }
  641.  
  642. static __inline__ void post_decide_line (void)
  643. {
  644.     static int warned = 0;
  645.     int tmp;
  646.  
  647.     if (thisline_decision.which == 1 && current_hpos () < thisline_decision.plfstrt + thisline_decision.plflinelen
  648.     && ((bplcon0 & 0x7000) == 0 || !dmaen (DMA_BITPLANE)))
  649.     {
  650.     /* This is getting gross... */
  651.     thisline_decision.plflinelen = current_hpos() - thisline_decision.plfstrt;
  652.     thisline_decision.plflinelen &= 7;
  653.     if (thisline_decision.plflinelen == 0)
  654.         thisline_decision.which = -1;
  655.     /* ... especially THIS! */
  656.     modulos_added = 1;
  657.     return;
  658.     }
  659.     
  660.     if (thisline_decision.which != -1 || diwstate == DIW_waiting_start || (bplcon0 & 0x7000) == 0
  661.     || !dmaen (DMA_BITPLANE) || current_hpos () >= thisline_decision.plfstrt + thisline_decision.plflinelen)
  662.     return;
  663. #if 0 /* Can't warn because Kickstart 1.3 does it at reset time ;-) */
  664.     if (!warned) {
  665.     write_log ("That program you are running is _really_ broken.\n");
  666.     warned = 1;
  667.     }
  668. #endif
  669.  
  670.     decided_hires = (bplcon0 & 0x8000) == 0x8000;
  671.     decided_nr_planes = nr_planes_from_bplcon0;
  672.  
  673.     /* Magic 12, Ray of Hope 2 demo does ugly things. Looks great from the
  674.      * outside, rotten inside. */
  675.     if (decided_hires) {
  676.     tmp = current_hpos () & ~3;
  677.     very_broken_program = current_hpos () & 3;
  678.     } else {
  679.     tmp = current_hpos () & ~7;
  680.     very_broken_program = current_hpos () & 7;
  681.     }
  682.     MARK_LINE_CHANGED (next_lineno); /* Play safe. */
  683.     decide_as_playfield (tmp, plflinelen + plfstrt - tmp);
  684. }
  685.  
  686. static void decide_line_1 (void)
  687. {
  688.     do_sprites(vpos, current_hpos ());
  689.  
  690.     /* Surprisingly enough, this seems to be correct here - putting this into
  691.      * decide_diw() results in garbage. */
  692.     if (diwstate == DIW_waiting_start && vpos == plffirstline) {
  693.     diwstate = DIW_waiting_stop;
  694.     calculate_copper_cycle_time ();
  695.     }
  696.     if (diwstate == DIW_waiting_stop && vpos == plflastline) {
  697.     diwstate = DIW_waiting_start;
  698.     calculate_copper_cycle_time ();
  699.     }
  700.  
  701.     if (framecnt != 0) {
  702. /*    thisline_decision.which = -2; This doesn't do anything but hurt, I think. */
  703.     return;
  704.     }
  705.  
  706.     if (!dmaen(DMA_BITPLANE) || diwstate == DIW_waiting_start || nr_planes_from_bplcon0 == 0) {
  707.     /* We don't want to draw this one. */
  708.     thisline_decision.which = -1;
  709.     thisline_decision.plfstrt = plfstrt;
  710.     thisline_decision.plflinelen = plflinelen;
  711.     return;
  712.     }
  713.  
  714.     decided_hires = (bplcon0 & 0x8000) == 0x8000;
  715.     decided_nr_planes = nr_planes_from_bplcon0;
  716. #if 0
  717.     /* The blitter gets slower if there's high bitplane activity. 
  718.      * @@@ but the values must be different. FIXME */
  719.     if (bltstate != BLT_done
  720.     && ((decided_hires && decided_nr_planes > 2)
  721.         || (!decided_hires && decided_nr_planes > 4)))
  722.     {
  723.     int pl = decided_nr_planes;
  724.     unsigned int n = (eventtab[ev_blitter].evtime-cycles);
  725.     if (n > plflinelen)
  726.         n = plflinelen;
  727.     n >>= 1;
  728.     if (decided_hires)
  729.         pl <<= 1;
  730.     if (pl == 8)
  731.         eventtab[ev_blitter].evtime += plflinelen;
  732.     else if (pl == 6)
  733.         eventtab[ev_blitter].evtime += n*2;
  734.     else if (pl == 5)
  735.         eventtab[ev_blitter].evtime += n*3/2;
  736.     events_schedule();
  737.     }
  738. #endif
  739.     decide_as_playfield (plfstrt, plflinelen);
  740. }
  741.  
  742. static __inline__ void decide_line (void)
  743. {
  744.     if (thisline_decision.which == 0 && current_hpos() >= plfstrt)
  745.     decide_line_1 ();
  746. }
  747.  
  748. static void record_color_change (int regno, unsigned long value)
  749. {
  750.     /* Early positions don't appear on-screen. */
  751.     if (framecnt != 0 || vpos < minfirstline || current_hpos () < 0x18
  752.     /*|| currprefs.emul_accuracy == 0*/)
  753.     return;
  754.  
  755.     decide_diw ();
  756.     decide_line ();
  757.  
  758.     /* See if we can record the color table, but have not done so yet.
  759.      * @@@ There might be a minimal performance loss in case someone changes
  760.      * a color exactly at the start of the DIW. I don't think it can actually
  761.      * fail to work even in this case, but I'm not 100% sure.
  762.      * @@@ There might be a slightly larger performance loss if we're drawing
  763.      * this line as border... especially if there are changes in colors != 0
  764.      * we might end up setting line_changed for no reason. FIXME */
  765.     if (thisline_decision.diwfirstword >= 0) {
  766.     if (thisline_decision.ctable == -1)
  767.         remember_ctable ();
  768.     }
  769.  
  770.     /* Changes outside the DIW can be ignored if the modified color is not the
  771.      * background color, or if the accuracy is < 2. */
  772.     if ((regno != 0 || currprefs.emul_accuracy < 2)
  773.     && (diwstate == DIW_waiting_start || thisline_decision.diwfirstword < 0
  774.         || thisline_decision.diwlastword >= 0
  775.         || thisline_decision.which == 0
  776.         || (thisline_decision.which == 1 && current_hpos() >= thisline_decision.plfstrt + thisline_decision.plflinelen)))
  777.     return;
  778.     
  779.     /* If the border is changed the first time before the DIW, record the
  780.      * original starting border value. */
  781.     if (regno == 0 && thisline_decision.color0 == 0xFFFFFFFFul && thisline_decision.diwfirstword < 0) {
  782.     thisline_decision.color0 = current_colors.color_regs[0];
  783.     if (line_decisions[next_lineno].color0 != value)
  784.         line_changed[next_lineno] = 1;
  785.     }
  786.     /* Anything else gets recorded in the color_changes table. */
  787. #ifdef OS_WITHOUT_MEMORY_MANAGEMENT
  788.     if(next_color_change >= max_color_change) {
  789.         ++delta_color_change;
  790.     return;
  791.     }
  792. #endif
  793.     curr_color_changes[next_color_change].linepos = current_hpos ();
  794.     curr_color_changes[next_color_change].regno = regno;
  795.     curr_color_changes[next_color_change++].value = value;
  796. }
  797.  
  798. static void decide_delay (void)
  799. {
  800.     static int warned;
  801.  
  802.     /* Don't do anything if we're outside the DIW. */
  803.     if (thisline_decision.diwfirstword == -1 || thisline_decision.diwlastword > 0)
  804.     return;
  805.     decide_line ();
  806.     /* Half-hearted attempt to get things right even when post_decide_line() changes
  807.      * the decision afterwards. */
  808.     if (thisline_decision.which != 1) {
  809.     thisline_decision.bplcon1 = bplcon1;
  810.     return;
  811.     }
  812.     /* @@@ Could check here for DDF stopping earlier than DIW */
  813.     
  814. #ifdef OS_WITHOUT_MEMORY_MANAGEMENT
  815.     if(next_delay_change >= max_delay_change) {
  816.         ++delta_delay_change;
  817.     return;
  818.     }
  819. #endif
  820.     delay_changes[next_delay_change].linepos = current_hpos ();
  821.     delay_changes[next_delay_change++].value = bplcon1;
  822.     if (!warned) {
  823.     warned = 1;
  824.     write_log ("Program is torturing BPLCON1.\n");
  825.     }
  826. }
  827.  
  828. /*
  829.  * The decision which bitplane pointers to use is not taken at plfstrt, since
  830.  * data fetch does not start for all planes at this point. Therefore, we wait
  831.  * for the end of the ddf area or the first write to any of the bitplane
  832.  * pointer registers, whichever comes last, before we decide which plane pointers
  833.  * to use.
  834.  * Call decide_line() before this function.
  835.  */
  836. static void decide_plane (void)
  837. {
  838.     int i, bytecount;
  839.  
  840.     if (framecnt != 0 || plane_decided)
  841.     return;
  842.  
  843.     if (decided_nr_planes == -1 /* Still undecided */
  844.     || current_hpos () < thisline_decision.plfstrt + thisline_decision.plflinelen)
  845.     return;
  846.  
  847.     plane_decided = 1;
  848.  
  849.     bytecount = plflinelen / (decided_hires ? 4 : 8) * 2;
  850.  
  851.     if (bytecount > MAX_WORDS_PER_LINE * 2) {
  852.     /* Can't happen. */
  853.     static int warned = 0;
  854.     if (!warned)
  855.         write_log ("Mysterious bug in decide_plane(). Please report.\n");
  856.     bytecount = 0;
  857.     }
  858.     if (!very_broken_program) {
  859.     uae_u8 *dataptr = line_data[next_lineno];
  860.     for (i = 0; i < decided_nr_planes; i++, dataptr += MAX_WORDS_PER_LINE*2) {
  861.         uaecptr pt = bplpt[i];
  862.         uae_u8 *real_ptr = pfield_xlateptr(pt, bytecount);
  863.         if (real_ptr == NULL)
  864.         real_ptr = pfield_xlateptr(0, 0);
  865. #ifdef SMART_UPDATE
  866. #if 1
  867.         if (line_changed[next_lineno])
  868.         memcpy (dataptr, real_ptr, bytecount);
  869.         else
  870. #endif
  871.         line_changed[next_lineno] |= memcmpy (dataptr, real_ptr, bytecount);
  872. #else
  873.         real_bplpt[i] = real_ptr;
  874. #endif
  875.     }
  876.     } else {
  877.     uae_u8 *dataptr = line_data[next_lineno];
  878.     for (i = 0; i < decided_nr_planes; i++, dataptr += MAX_WORDS_PER_LINE*2) {
  879.         uaecptr pt = bplpt[i];
  880.         uae_u8 *real_ptr;
  881.         
  882.         if (decided_hires) {
  883.         switch (i) {
  884.          case 3: pt -= 2;
  885.          case 2: pt -= (very_broken_program >= 3 ? 2 : 0); break;
  886.          case 1: pt -= (very_broken_program >= 2 ? 2 : 0); break;
  887.          case 0: break;
  888.         }
  889.         } else {
  890.         switch (i) {
  891.          case 5: pt -= (very_broken_program >= 3 ? 2 : 0); break;
  892.          case 4: pt -= (very_broken_program >= 7 ? 2 : 0); break;
  893.          case 3: pt -= (very_broken_program >= 2 ? 2 : 0); break;
  894.          case 2: pt -= (very_broken_program >= 6 ? 2 : 0); break;
  895.          case 1: pt -= (very_broken_program >= 4 ? 2 : 0); break;
  896.          case 0: break;
  897.         }
  898.         }
  899.         real_ptr = pfield_xlateptr(pt, bytecount);
  900.         if (real_ptr == NULL)
  901.         real_ptr = pfield_xlateptr(0, 0);
  902. #ifdef SMART_UPDATE
  903.         if (!line_changed[next_lineno])
  904.         line_changed[next_lineno] |= memcmpy (dataptr, real_ptr, bytecount);
  905.         else
  906.         memcpy (dataptr, real_ptr, bytecount);
  907. #else
  908.         real_bplpt[i] = real_ptr;
  909. #endif
  910.     }
  911.     }
  912. }
  913.  
  914. /*
  915.  * Called from the BPLxMOD routines, after a new value has been written.
  916.  * This routine decides whether the new value is already relevant for the
  917.  * current line.
  918.  */
  919. static void decide_modulos (void)
  920. {
  921.     /* All this effort just for the Sanity WOC demo... */
  922.     decide_line ();
  923.     if (decided_nr_planes != -1 && current_hpos() >= thisline_decision.plfstrt + thisline_decision.plflinelen)
  924.     return;
  925.     decided_bpl1mod = bpl1mod;
  926.     decided_bpl2mod = bpl2mod;
  927. }
  928.  
  929. /*
  930.  * Call decide_plane() before calling this.
  931.  */
  932. static void do_modulos (void)
  933. {
  934.     /* decided_nr_planes is != -1 if this line should be drawn by the
  935.      * display hardware, regardless of whether it fits on the emulated screen. 
  936.      */
  937.     if (decided_nr_planes != -1 && plane_decided && !modulos_added
  938.     && current_hpos() >= thisline_decision.plfstrt + thisline_decision.plflinelen)
  939.     {
  940.     int bytecount = thisline_decision.plflinelen / (decided_hires ? 4 : 8) * 2;
  941.     int add1 = bytecount + decided_bpl1mod;
  942.     int add2 = bytecount + decided_bpl2mod;
  943.  
  944.     if (!very_broken_program) {
  945.         switch (decided_nr_planes) {
  946.          case 8: bplpt[7] += add2;
  947.          case 7: bplpt[6] += add1;
  948.          case 6: bplpt[5] += add2;
  949.          case 5: bplpt[4] += add1;
  950.          case 4: bplpt[3] += add2;
  951.          case 3: bplpt[2] += add1;
  952.          case 2: bplpt[1] += add2;
  953.          case 1: bplpt[0] += add1;
  954.         }
  955.     } else if (bplhires) {
  956.         switch (decided_nr_planes) {
  957.          case 8: bplpt[7] += add2;
  958.          case 7: bplpt[6] += add1;
  959.          case 6: bplpt[5] += add2;
  960.          case 5: bplpt[4] += add1;
  961.          case 4: bplpt[3] += add2 - 2;
  962.          case 3: bplpt[2] += add1 - (very_broken_program >= 3 ? 2 : 0);
  963.          case 2: bplpt[1] += add2 - (very_broken_program >= 2 ? 2 : 0);
  964.          case 1: bplpt[0] += add1;
  965.          }
  966.     } else {
  967.         switch (decided_nr_planes) {
  968.          case 8: bplpt[7] += add2;
  969.          case 7: bplpt[6] += add1;
  970.          case 6: bplpt[5] += add2 - (very_broken_program >= 3 ? 2 : 0);
  971.          case 5: bplpt[4] += add1 - (very_broken_program >= 7 ? 2 : 0);
  972.          case 4: bplpt[3] += add2 - (very_broken_program >= 2 ? 2 : 0);
  973.          case 3: bplpt[2] += add1 - (very_broken_program >= 6 ? 2 : 0);
  974.          case 2: bplpt[1] += add2 - (very_broken_program >= 4 ? 2 : 0);
  975.          case 1: bplpt[0] += add1;
  976.          }
  977.     }
  978.  
  979.     modulos_added = 1;
  980.     }
  981. }
  982.  
  983. static __inline__ void record_sprite (int spr, int sprxp)
  984. {
  985.     int pos = next_sprite_draw;
  986.     unsigned int data, datb;
  987.  
  988. #ifdef OS_WITHOUT_MEMORY_MANAGEMENT
  989.     if(pos >= max_sprite_draw) {
  990.         ++delta_sprite_draw;
  991.         return;
  992.     }
  993. #endif
  994.     data = sprdata[spr];
  995.     datb = sprdatb[spr];
  996.  
  997.     /* XXX FIXME, this isn't very clever, but it might do */
  998.     for (;;) {
  999.     if (pos == curr_drawinfo[next_lineno].first_sprite_draw)
  1000.         break;
  1001.     if (curr_sprite_positions[pos-1].linepos < sprxp)
  1002.         break;
  1003.     if (curr_sprite_positions[pos-1].linepos == sprxp
  1004.         && curr_sprite_positions[pos-1].num > spr)
  1005.         break;
  1006.     printf("Foo\n");
  1007.     pos--;
  1008.     }
  1009.     if (pos != next_sprite_draw) {
  1010.     int pos2 = next_sprite_draw;
  1011.     while (pos2 != pos) {
  1012.         curr_sprite_positions[pos2] = curr_sprite_positions[pos2-1];
  1013.         pos2--;
  1014.     }
  1015.     }
  1016.     curr_sprite_positions[pos].linepos = sprxp;
  1017.     curr_sprite_positions[pos].num = spr;
  1018.     curr_sprite_positions[pos].ctl = sprctl[spr];
  1019.     curr_sprite_positions[pos].datab = ((sprtaba[data & 0xFF] << 16) | sprtaba[data >> 8]
  1020.                     | (sprtabb[datb & 0xFF] << 16) | sprtabb[datb >> 8]);
  1021.     next_sprite_draw++;
  1022. }
  1023.  
  1024. static void decide_sprites (void)
  1025. {
  1026.     int nrs[8], posns[8], count, i;
  1027.     int point = PIXEL_XPOS (current_hpos ());
  1028.  
  1029.     if (framecnt != 0 || current_hpos() < 0x14 || nr_armed == 0 || point == last_sprite_point)
  1030.     return;
  1031.  
  1032.     decide_diw ();
  1033.     decide_line ();
  1034.  
  1035.     if (thisline_decision.which != 1)
  1036.     return;
  1037.  
  1038.     count = 0;
  1039.     for (i = 0; i < 8; i++) {
  1040.     int sprxp = sprxpos[i];
  1041.     int j, bestp;
  1042.     
  1043.     if (!sprarmed[i] || sprxp < 0 || sprxp > point || last_sprite_point >= sprxp)
  1044.         continue;
  1045.     if ((thisline_decision.diwfirstword >= 0 && sprxp + sprite_width < thisline_decision.diwfirstword)
  1046.         || (thisline_decision.diwlastword >= 0 && sprxp > thisline_decision.diwlastword))
  1047.         continue;
  1048.     
  1049.     for (bestp = 0; bestp < count; bestp++) {
  1050.         if (posns[bestp] > sprxp)
  1051.         break;
  1052.         if (posns[bestp] == sprxp && nrs[bestp] < i)
  1053.         break;
  1054.     }
  1055.     for (j = count; j > bestp; j--) {
  1056.         posns[j] = posns[j-1];
  1057.         nrs[j] = nrs[j-1];
  1058.     }
  1059.     posns[j] = sprxp;
  1060.     nrs[j] = i;
  1061.     count++;
  1062.     }
  1063.     for (i = 0; i < count; i++)
  1064.     record_sprite(nrs[i], posns[i]);
  1065.     last_sprite_point = point;
  1066. }
  1067.  
  1068. static void finish_decisions (void)
  1069. {
  1070.     struct draw_info *dip;
  1071.     struct draw_info *dip_old;
  1072.     struct decision *dp;
  1073.     int changed;
  1074.  
  1075.     if (framecnt != 0)
  1076.     return;
  1077.  
  1078.     decide_diw ();
  1079.     if (thisline_decision.which == 0)
  1080.     decide_line_1 ();
  1081.  
  1082.     if (hdiwstate == DIW_waiting_stop) {
  1083.     thisline_decision.diwlastword = max_diwlastword;
  1084.     if (thisline_decision.diwlastword != line_decisions[next_lineno].diwlastword)
  1085.         MARK_LINE_CHANGED (next_lineno);
  1086.     }
  1087.  
  1088.     if (line_decisions[next_lineno].which != thisline_decision.which)
  1089.     line_changed[next_lineno] = 1;
  1090.     decide_plane ();
  1091.  
  1092.     dip = curr_drawinfo + next_lineno;
  1093.     dip_old = prev_drawinfo + next_lineno;
  1094.     dp = line_decisions + next_lineno;
  1095.     changed = line_changed[next_lineno];
  1096.  
  1097.     if (thisline_decision.which == 1) {
  1098.     if (diwlastword > max_diwstop)
  1099.         max_diwstop = diwlastword;
  1100.     if (diwfirstword < min_diwstart)
  1101.         min_diwstart = diwfirstword;
  1102.  
  1103.     decide_sprites();
  1104.  
  1105.     if (thisline_decision.bplcon1 != line_decisions[next_lineno].bplcon1)
  1106.         changed = 1;
  1107.     }
  1108.  
  1109.     dip->last_color_change = next_color_change;
  1110.     dip->last_delay_change = next_delay_change;
  1111.     dip->last_sprite_draw = next_sprite_draw;
  1112.     
  1113.     if (thisline_decision.ctable == -1) {
  1114.     if (thisline_decision.which == 1)
  1115.         remember_ctable ();
  1116.     else
  1117.         remember_ctable_for_border ();
  1118.     }
  1119.     if (thisline_decision.which == -1 && thisline_decision.color0 == 0xFFFFFFFFul)
  1120.     thisline_decision.color0 = current_colors.color_regs[0];
  1121.  
  1122.     dip->nr_color_changes = next_color_change - dip->first_color_change;
  1123.     dip->nr_sprites = next_sprite_draw - dip->first_sprite_draw;
  1124.  
  1125.     if (dip->first_delay_change != dip->last_delay_change)
  1126.     changed = 1;
  1127.     if (!changed
  1128.     && (dip->nr_color_changes != dip_old->nr_color_changes
  1129.         || (dip->nr_color_changes > 0 
  1130.         && fast_memcmp (curr_color_changes + dip->first_color_change,
  1131.                 prev_color_changes + dip_old->first_color_change,
  1132.                 dip->nr_color_changes * sizeof *curr_color_changes) != 0)))
  1133.     changed = 1;
  1134.     if (!changed && thisline_decision.which == 1
  1135.     && (dip->nr_sprites != dip_old->nr_sprites
  1136.         || (dip->nr_sprites > 0
  1137.         && fast_memcmp (curr_sprite_positions + dip->first_sprite_draw,
  1138.                 prev_sprite_positions + dip_old->first_sprite_draw,
  1139.                 dip->nr_sprites * sizeof *curr_sprite_positions) != 0)))
  1140.     changed = 1;
  1141.  
  1142.     if (changed) {
  1143.     line_changed[next_lineno] = 1;
  1144.     *dp = thisline_decision;
  1145.     } else
  1146.     /* The only one that may differ: */
  1147.     dp->ctable = thisline_decision.ctable;
  1148. }
  1149.  
  1150. static void reset_decisions (void)
  1151. {
  1152.     if (framecnt != 0)
  1153.     return;
  1154.     thisline_decision.which = 0;
  1155.     decided_bpl1mod = bpl1mod;
  1156.     decided_bpl2mod = bpl2mod;
  1157.     decided_nr_planes = -1;
  1158.  
  1159.     /* decided_hires shouldn't be touched before it's initialized by decide_line(). */
  1160.     thisline_decision.diwfirstword = -1;
  1161.     thisline_decision.diwlastword = -2;
  1162.     if (hdiwstate == DIW_waiting_stop) {
  1163.     thisline_decision.diwfirstword = PIXEL_XPOS (DISPLAY_LEFT_SHIFT/2);
  1164.     if (thisline_decision.diwfirstword != line_decisions[next_lineno].diwfirstword)
  1165.         MARK_LINE_CHANGED (next_lineno);
  1166.     }
  1167.     thisline_decision.ctable = -1;
  1168.     thisline_decision.color0 = 0xFFFFFFFFul;
  1169.  
  1170.     line_changed[next_lineno] = 0;
  1171.     curr_drawinfo[next_lineno].first_color_change = next_color_change;
  1172.     curr_drawinfo[next_lineno].first_delay_change = next_delay_change;
  1173.     curr_drawinfo[next_lineno].first_sprite_draw = next_sprite_draw;
  1174.  
  1175.     /*memset(sprite_last_drawn_at, 0, sizeof sprite_last_drawn_at);*/
  1176.     last_sprite_point = 0;
  1177.     modulos_added = 0;
  1178.     plane_decided = 0;
  1179.     color_decided = 0;
  1180.     very_broken_program = 0;
  1181. }
  1182.  
  1183. static void init_decisions (void)
  1184. {
  1185.     size_t i;
  1186.     for (i = 0; i < sizeof line_decisions / sizeof *line_decisions; i++) {
  1187.     line_decisions[i].which = -2;
  1188.     }
  1189. }
  1190.  
  1191. static void calcdiw (void)
  1192. {
  1193.     diwfirstword = ((diwstrt & 0xFF) - DISPLAY_LEFT_SHIFT - 1) << lores_shift;
  1194.     diwlastword  = ((diwstop & 0xFF) + 0x100 - DISPLAY_LEFT_SHIFT - 1) << lores_shift;
  1195.  
  1196.     if (diwlastword > max_diwlastword)
  1197.     diwlastword = max_diwlastword;
  1198.     if (diwfirstword < 0)
  1199.     diwfirstword = 0;
  1200.     if (diwlastword < 0)
  1201.     diwlastword = 0;
  1202.     
  1203.     plffirstline = diwstrt >> 8;
  1204.     plflastline = diwstop >> 8;
  1205. #if 0
  1206.     /* This happens far too often. */
  1207.     if (plffirstline < minfirstline) {
  1208.     fprintf(stderr, "Warning: Playfield begins before line %d!\n", minfirstline);
  1209.     plffirstline = minfirstline;
  1210.     }
  1211. #endif
  1212.     if ((plflastline & 0x80) == 0) plflastline |= 0x100;
  1213. #if 0 /* Turrican does this */
  1214.     if (plflastline > 313) {
  1215.     fprintf(stderr, "Warning: Playfield out of range!\n");
  1216.     plflastline = 313;
  1217.     }
  1218. #endif
  1219.     plfstrt = ddfstrt;
  1220.     plfstop = ddfstop;
  1221.     if (plfstrt < 0x18) plfstrt = 0x18;
  1222.     if (plfstop < 0x18) plfstop = 0x18;
  1223.     if (plfstop > 0xD8) plfstop = 0xD8;
  1224.     if (plfstrt > plfstop) plfstrt = plfstop;
  1225.  
  1226.     /* ! If the masking operation is changed, the pfield_doline code could break
  1227.      * on some systems (alignment) */
  1228.     /* This actually seems to be correct now, at least the non-AGA stuff... */
  1229.     plfstrt &= ~3;
  1230.     plfstop &= ~3;
  1231.     /* @@@ Start looking for AGA bugs here... (or maybe even in the above masking ops) */
  1232.     if ((fmode & 3) == 0)
  1233.     plflinelen = (plfstop-plfstrt+15) & ~7;
  1234.     else if ((fmode & 3) == 3)
  1235.     plflinelen = (plfstop-plfstrt+63) & ~31;
  1236.     else
  1237.     plflinelen = (plfstop-plfstrt+31) & ~15;
  1238. }
  1239.  
  1240. /*
  1241.  * Screen update macros/functions
  1242.  */
  1243.  
  1244. static unsigned int ham_lastcolor;
  1245.  
  1246. static void init_ham_decoding(int first)
  1247. {
  1248.     int pix = dp_for_drawing->diwfirstword;
  1249.     ham_lastcolor = colors_for_drawing.color_regs[0];
  1250.     while (pix < first) {
  1251.     int pv = pixdata.apixels[pix];
  1252.     switch(pv & 0x30) {
  1253.      case 0x00: ham_lastcolor = colors_for_drawing.color_regs[pv]; break;
  1254.      case 0x10: ham_lastcolor &= 0xFF0; ham_lastcolor |= (pv & 0xF); break;
  1255.      case 0x20: ham_lastcolor &= 0x0FF; ham_lastcolor |= (pv & 0xF) << 8; break;
  1256.      case 0x30: ham_lastcolor &= 0xF0F; ham_lastcolor |= (pv & 0xF) << 4; break;
  1257.     }
  1258.     pix++;
  1259.     }
  1260. }
  1261.  
  1262. static void decode_ham6 (int pix, int stoppos)
  1263. {
  1264.     uae_u32 *buf = ham_linebuf; 
  1265.  
  1266.     if (!bplham || bplplanecnt != 6)
  1267.     return;
  1268.     
  1269.     if (stoppos > dp_for_drawing->diwlastword)
  1270.     stoppos = dp_for_drawing->diwlastword;
  1271.     if (pix < dp_for_drawing->diwfirstword) {
  1272.     ham_lastcolor = colors_for_drawing.color_regs[0];
  1273.     pix = dp_for_drawing->diwfirstword;
  1274.     }
  1275. #ifdef LORES_HACK
  1276.     if (currprefs.gfx_lores == 2)
  1277.     pix <<= 1, stoppos <<= 1;
  1278. #endif
  1279.     while (pix < stoppos) {
  1280.     int pv = pixdata.apixels[pix];
  1281.     switch(pv & 0x30) {
  1282.      case 0x00: ham_lastcolor = colors_for_drawing.color_regs[pv]; break;
  1283.      case 0x10: ham_lastcolor &= 0xFF0; ham_lastcolor |= (pv & 0xF); break;
  1284.      case 0x20: ham_lastcolor &= 0x0FF; ham_lastcolor |= (pv & 0xF) << 8; break;
  1285.      case 0x30: ham_lastcolor &= 0xF0F; ham_lastcolor |= (pv & 0xF) << 4; break;
  1286.     }
  1287.  
  1288.     buf[pix++] = ham_lastcolor;
  1289.     }    
  1290. }
  1291. #if 0
  1292. static void decode_ham_aga (int pix, int stoppos)
  1293. {
  1294.     static uae_u32 lastcolor;
  1295.     uae_u32 *buf = ham_linebuf; 
  1296.  
  1297.     if (!bplham || (bplplanecnt != 6 && bplplanecnt != 8))
  1298.     return;
  1299.     
  1300.     if (pix <= dp_for_drawing->diwfirstword) {
  1301.     pix = dp_for_drawing->diwfirstword;
  1302.     lastcolor = colors_for_drawing.color_regs[0];
  1303.     }
  1304.  
  1305.     if (dp_for_drawing->bplplanecnt == 6) {
  1306.     /* HAM 6 */
  1307.     while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
  1308.         int pv = pixdata.apixels[pix];
  1309.         switch(pv & 0x30) {
  1310.          case 0x00: lastcolor = colors_for_drawing.color_regs[pv]; break;
  1311.          case 0x10: lastcolor &= 0xFFFF00; lastcolor |= (pv & 0xF)*0x11; break;
  1312.          case 0x20: lastcolor &= 0x00FFFF; lastcolor |= (pv & 0xF)*0x11 << 16; break;
  1313.          case 0x30: lastcolor &= 0xFF00FF; lastcolor |= (pv & 0xF)*0x11 << 8; break;
  1314.         }        
  1315.         buf[pix++] = lastcolor;
  1316.     }
  1317.     } else if (dp_for_drawing->bplplanecnt == 8) {
  1318.     /* HAM 8 */
  1319.     while (pix < dp_for_drawing->diwlastword && pix < stoppos) {
  1320.         int pv = pixdata.apixels[pix];
  1321.         switch(pv & 0x3) {
  1322.          case 0x0: lastcolor = colors_for_drawing.color_regs[pv >> 2]; break;
  1323.          case 0x1: lastcolor &= 0xFFFF03; lastcolor |= (pv & 0xFC); break;
  1324.          case 0x2: lastcolor &= 0x03FFFF; lastcolor |= (pv & 0xFC) << 16; break;
  1325.          case 0x3: lastcolor &= 0xFF03FF; lastcolor |= (pv & 0xFC) << 8; break;
  1326.         }
  1327.         buf[pix++] = lastcolor;
  1328.     }
  1329.     }
  1330. }
  1331. #endif
  1332.  
  1333. #if AGA_CHIPSET != 0
  1334. /* WARNING: Not too much of this will work correctly yet. */
  1335.  
  1336. static void pfield_linetoscr_aga(int pix, int stoppos)
  1337. {
  1338.     uae_u32 *buf = aga_lbufptr;
  1339.     int i;
  1340.     int xor = (uae_u8)(bplcon4 >> 8);
  1341.     int oldpix = pix; \
  1342.  
  1343.     buf -= pix; \
  1344.  
  1345.     for (i = 0; i < stoppos; i++)
  1346.     pixdata.apixels[i] ^= xor;
  1347.     
  1348.     while (pix < diwfirstword && pix < stoppos) {
  1349.     buf[pix++] = colors_for_drawing.color_regs[0];
  1350.     }
  1351.     if (bplham) {
  1352.     while (pix < diwlastword && pix < stoppos) {
  1353.         uae_u32 d = ham_linebuf[pix];
  1354.         buf[pix] = d;
  1355.         pix++;
  1356.     }
  1357.     } else if (bpldualpf) {
  1358.     /* Dual playfield */
  1359.     int *lookup = bpldualpfpri ? dblpf_aga2 : dblpf_aga1;
  1360.     int *lookup_no = bpldualpfpri ? dblpf_2nd2 : dblpf_2nd1;
  1361.     while (pix < diwlastword && pix < stoppos) {
  1362.         int pixcol = pixdata.apixels[pix];
  1363.         int pfno = lookup_no[pixcol];
  1364.         
  1365.         if (spixstate[pix]) {
  1366.             buf[pix] = colors_for_drawing.color_regs[pixcol];
  1367.         } else {
  1368.         int val = lookup[pixdata.apixels[pix]];
  1369.         if (pfno == 2) 
  1370.             val += dblpfofs[(bplcon2 >> 10) & 7];
  1371.         buf[pix] = colors_for_drawing.color_regs[val];
  1372.         }
  1373.         pix++;
  1374.     }
  1375.     } else if (bplehb) {
  1376.     while (pix < diwlastword && pix < stoppos) {
  1377.             int pixcol = pixdata.apixels[pix];
  1378.         uae_u32 d = colors_for_drawing.color_regs[pixcol];
  1379.         /* What about sprites? */
  1380.         if (pixcol & 0x20)
  1381.         d = (d & 0x777777) >> 1;
  1382.         buf[pix] = d;
  1383.         pix++;
  1384.     }
  1385.     } else {
  1386.     while (pix < diwlastword && pix < stoppos) {
  1387.         int pixcol = pixdata.apixels[pix];
  1388.         buf[pix] = colors_for_drawing.color_regs[pixcol];
  1389.         pix++;
  1390.     }
  1391.     }
  1392.     while (pix < stoppos) {
  1393.     buf[pix++] = colors_for_drawing.color_regs[0];
  1394.     }
  1395.     aga_lbufptr += pix - oldpix;
  1396. }
  1397.  
  1398. static void aga_translate32(int start, int stop)
  1399. {
  1400.     memcpy (((uae_u32 *)xlinebuffer) + start, aga_linebuf + start, 4*(stop-start));
  1401. }
  1402.  
  1403. static void aga_translate16(int start, int stop)
  1404. {
  1405.     int i;
  1406.     for (i = start; i < stop; i++) {
  1407.     uae_u32 d = aga_linebuf[i];
  1408.     uae_u16 v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
  1409.     ((uae_u16 *)xlinebuffer)[i] = xcolors[v];
  1410.     }
  1411. }
  1412.  
  1413. static void aga_translate8(int start, int stop)
  1414. {
  1415.     int i;
  1416.     for (i = start; i < stop; i++) {
  1417.     uae_u32 d = aga_linebuf[i];
  1418.     uae_u16 v = ((d & 0xF0) >> 4) | ((d & 0xF000) >> 8) | ((d & 0xF00000) >> 12);
  1419.     ((uae_u8 *)xlinebuffer)[i] = xcolors[v];
  1420.     }
  1421. }
  1422. #endif
  1423.  
  1424. static int linetoscr_double_offset;
  1425.  
  1426. #define LINE_TO_SCR(NAME, TYPE, DO_DOUBLE) \
  1427. static void NAME(int pix, int lframe_end, int diw_end, int stoppos) \
  1428. { \
  1429.     TYPE *buf = ((TYPE *)xlinebuffer); \
  1430.     int oldpix = pix; \
  1431.     /* These are different for register-allocation purposes. */ \
  1432.     TYPE d1, d2; \
  1433.     int offset; \
  1434. \
  1435.     if (DO_DOUBLE) offset = linetoscr_double_offset / sizeof(TYPE); \
  1436. \
  1437.     d1 = colors_for_drawing.acolors[0]; \
  1438.     while (pix < lframe_end) { \
  1439.     buf[pix] = d1; if (DO_DOUBLE) buf[pix+offset] = d1; \
  1440.     pix++; \
  1441.     } \
  1442.     if (bplham && bplplanecnt == 6) { \
  1443.     /* HAM 6 */ \
  1444.     while (pix < diw_end) { \
  1445.         TYPE d = xcolors[ham_linebuf[pix]]; \
  1446.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  1447.         pix++; \
  1448.     } \
  1449.     } else if (bpldualpf) { \
  1450.     /* Dual playfield */ \
  1451.     int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1; \
  1452.     while (pix < diw_end) { \
  1453.         int pixcol = pixdata.apixels[pix]; \
  1454.         TYPE d; \
  1455.         d = colors_for_drawing.acolors[lookup[pixcol]]; \
  1456.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  1457.         pix++; \
  1458.     } \
  1459.     } else if (bplehb) { \
  1460.     while (pix < diw_end) { \
  1461.         int p = pixdata.apixels[pix]; \
  1462.         TYPE d = colors_for_drawing.acolors[p]; \
  1463.         if (p >= 32) d = xcolors[(colors_for_drawing.color_regs[p-32] >> 1) & 0x777]; \
  1464.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  1465.         pix++; \
  1466.     } \
  1467.     } else { \
  1468.     while (pix < diw_end) { \
  1469.         TYPE d = colors_for_drawing.acolors[pixdata.apixels[pix]]; \
  1470.         buf[pix] = d; if (DO_DOUBLE) buf[pix+offset] = d; \
  1471.         pix++; \
  1472.     } \
  1473.     } \
  1474.     d2 = colors_for_drawing.acolors[0]; \
  1475.     while (pix < stoppos) { \
  1476.     buf[pix] = d2; if (DO_DOUBLE) buf[pix+offset] = d2; \
  1477.     pix++; \
  1478.     } \
  1479. }
  1480.  
  1481. #define FILL_LINE(NAME, TYPE) \
  1482. static void NAME(char *buf, int start, int stop) \
  1483. { \
  1484.     TYPE *b = (TYPE *)buf; \
  1485.     int i;\
  1486.     xcolnr col = colors_for_drawing.acolors[0]; \
  1487.     for (i = start; i < stop; i++) \
  1488.         b[i] = col; \
  1489. }
  1490.  
  1491. #ifdef __mac__
  1492.  
  1493. static void inline pfield_linetoscr_8(int pix, int lframe_end, int diw_end, int stoppos)
  1494. {
  1495.     uae_u8 *buf = ((uae_u8 *)xlinebuffer);
  1496.     int oldpix = pix;
  1497.     /* These are different for register-allocation purposes. */
  1498.     uae_u8 d1, d2;
  1499.     //int offset;
  1500.     
  1501.     d1 = ~colors_for_drawing.acolors[0];
  1502.     while (pix < lframe_end) {
  1503.     buf[pix] = d1;
  1504.     pix++;
  1505.     }
  1506.     if (bplham && bplplanecnt == 6) {
  1507.     /* HAM 6 */
  1508.     while (pix < diw_end) {
  1509.         uae_u8 d = ~xcolors[ham_linebuf[pix]];
  1510.         buf[pix] = d;
  1511.         pix++;
  1512.     }
  1513.     } else if (bpldualpf) {
  1514.     /* Dual playfield */
  1515.     int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1;
  1516.     while (pix < diw_end) {
  1517.         int pixcol = pixdata.apixels[pix];
  1518.         uae_u8 d;
  1519.         d = ~colors_for_drawing.acolors[lookup[pixcol]];
  1520.         buf[pix] = d;
  1521.         pix++;
  1522.     }
  1523.     } else if (bplehb) {
  1524.     while (pix < diw_end) {
  1525.         int p = pixdata.apixels[pix];
  1526.         uae_u8 d = ~colors_for_drawing.acolors[p];
  1527.         if (p >= 32) d = ~(xcolors[(colors_for_drawing.color_regs[p-32] >> 1) & 0x777]);
  1528.         buf[pix] = d;
  1529.         pix++;
  1530.     }
  1531.     } else {
  1532.     while (pix < diw_end) {
  1533.         uae_u8 d = ~colors_for_drawing.acolors[pixdata.apixels[pix]];
  1534.         buf[pix] = d;
  1535.         pix++;
  1536.     }
  1537.     }
  1538.     d2 = ~colors_for_drawing.acolors[0];
  1539.     while (pix < stoppos) {
  1540.     buf[pix] = d2;
  1541.     pix++;
  1542.     }
  1543. }
  1544.  
  1545. static void inline pfield_linetoscr_8_double_slow(int pix, int lframe_end, int diw_end, int stoppos)
  1546. {
  1547.     uae_u8 *buf = ((uae_u8 *)xlinebuffer);
  1548.     int oldpix = pix;
  1549.     /* These are different for register-allocation purposes. */
  1550.     uae_u8 d1, d2;
  1551.     int offset;
  1552.  
  1553.     offset = linetoscr_double_offset / sizeof(uae_u8);
  1554.     
  1555.     d1 = ~colors_for_drawing.acolors[0];
  1556.     while (pix < lframe_end) {
  1557.     buf[pix] = d1;
  1558.     buf[pix+offset] = d1;
  1559.     pix++;
  1560.     }
  1561.     if (bplham && bplplanecnt == 6) {
  1562.     /* HAM 6 */
  1563.     while (pix < diw_end) {
  1564.         uae_u8 d = ~xcolors[ham_linebuf[pix]];
  1565.         buf[pix] = d;
  1566.         buf[pix+offset] = d;
  1567.         pix++;
  1568.     }
  1569.     } else if (bpldualpf) {
  1570.     /* Dual playfield */
  1571.     int *lookup = bpldualpfpri ? dblpf_ind2 : dblpf_ind1;
  1572.     while (pix < diw_end) {
  1573.         int pixcol = pixdata.apixels[pix];
  1574.         uae_u8 d;
  1575.         d = ~colors_for_drawing.acolors[lookup[pixcol]];
  1576.         buf[pix] = d;
  1577.         buf[pix+offset] = d;
  1578.         pix++;
  1579.     }
  1580.     } else if (bplehb) {
  1581.     while (pix < diw_end) {
  1582.         int p = pixdata.apixels[pix];
  1583.         uae_u8 d = ~colors_for_drawing.acolors[p];
  1584.         if (p >= 32) d = ~(xcolors[(colors_for_drawing.color_regs[p-32] >> 1) & 0x777]);
  1585.         buf[pix] = d;
  1586.         buf[pix+offset] = d;
  1587.         pix++;
  1588.     }
  1589.     } else {
  1590.     while (pix < diw_end) {
  1591.         uae_u8 d = ~colors_for_drawing.acolors[pixdata.apixels[pix]];
  1592.         buf[pix] = d;
  1593.         buf[pix+offset] = d;
  1594.         pix++;
  1595.     }
  1596.     }
  1597.     d2 = ~colors_for_drawing.acolors[0];
  1598.     while (pix < stoppos) {
  1599.     buf[pix] = d2;
  1600.     buf[pix+offset] = d2;
  1601.     pix++;
  1602.     }
  1603. }
  1604.  
  1605. static void inline fill_line_8(char *buf, int start, int stop)
  1606. {
  1607.     uae_u8 *b = (uae_u8 *)buf;
  1608.     int i;
  1609.     xcolnr col = ~colors_for_drawing.acolors[0];
  1610.     for (i = start; i < stop; i++)
  1611.         b[i] = col;
  1612. }
  1613. #else // !__mac__
  1614. LINE_TO_SCR(pfield_linetoscr_8, uae_u8, 0)
  1615. LINE_TO_SCR(pfield_linetoscr_8_double_slow, uae_u8, 1)
  1616. FILL_LINE(fill_line_8, uae_u8)
  1617. #endif
  1618.  
  1619. LINE_TO_SCR(pfield_linetoscr_16, uae_u16, 0)
  1620. LINE_TO_SCR(pfield_linetoscr_32, uae_u32, 0)
  1621. LINE_TO_SCR(pfield_linetoscr_16_double_slow, uae_u16, 1)
  1622. LINE_TO_SCR(pfield_linetoscr_32_double_slow, uae_u32, 1)
  1623.  
  1624. FILL_LINE(fill_line_16, uae_u16)
  1625. FILL_LINE(fill_line_32, uae_u32)
  1626.  
  1627. static __inline__ void fill_line_full (void)
  1628. {
  1629.     switch (gfxvidinfo.pixbytes) {
  1630.      case 1: fill_line_8(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.maxlinetoscr); break;
  1631.      case 2: fill_line_16(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.maxlinetoscr); break;
  1632.      case 4: fill_line_32(xlinebuffer, linetoscr_x_adjust, linetoscr_x_adjust + gfxvidinfo.maxlinetoscr); break;
  1633.     }
  1634. }
  1635.  
  1636. #define fill_line fill_line_full
  1637.  
  1638. #define pfield_linetoscr_full8 pfield_linetoscr_8
  1639. #define pfield_linetoscr_full16 pfield_linetoscr_16
  1640. #define pfield_linetoscr_full32 pfield_linetoscr_32
  1641.  
  1642. #define pfield_linetoscr_full8_double pfield_linetoscr_8_double_slow
  1643. #define pfield_linetoscr_full16_double pfield_linetoscr_16_double_slow
  1644. #define pfield_linetoscr_full32_double pfield_linetoscr_32_double_slow
  1645.  
  1646. #if 1 && defined(X86_ASSEMBLY)
  1647. /* This version of fill_line is probably a win on all machines, but for
  1648.  * now I'm cautious */
  1649. #undef fill_line
  1650. static __inline__ void fill_line (void)
  1651. {
  1652.     int shift;
  1653.     int nints, nrem;
  1654.     int *start;
  1655.     xcolnr val;
  1656.  
  1657.     shift = 0;
  1658.     if (gfxvidinfo.pixbytes == 2)
  1659.     shift = 1;
  1660.     if (gfxvidinfo.pixbytes == 4)
  1661.     shift = 2;
  1662.  
  1663.     nints = gfxvidinfo.maxlinetoscr >> (2-shift);
  1664.     nrem = nints & 7;
  1665.     nints &= ~7;
  1666.     start = (int *)(((char *)xlinebuffer) + (linetoscr_x_adjust << shift));
  1667.     val = colors_for_drawing.acolors[0];
  1668.     for (; nints > 0; nints -= 8, start+=8) {
  1669.     *start = val;
  1670.     *(start+1) = val;
  1671.     *(start+2) = val;
  1672.     *(start+3) = val;
  1673.     *(start+4) = val;
  1674.     *(start+5) = val;
  1675.     *(start+6) = val;
  1676.     *(start+7) = val;
  1677.     }
  1678.     
  1679.     switch (nrem) {
  1680.      case 7:
  1681.     *start++ = val;
  1682.      case 6:
  1683.     *start++ = val;
  1684.      case 5:
  1685.     *start++ = val;
  1686.      case 4:
  1687.     *start++ = val;
  1688.      case 3:
  1689.     *start++ = val;
  1690.      case 2:
  1691.     *start++ = val;
  1692.      case 1:
  1693.     *start = val;
  1694.     }
  1695. }
  1696.  
  1697. #undef pfield_linetoscr_full8
  1698. /* The types are lies, of course. */
  1699. extern void pfield_linetoscr_normal_asm8(void) __asm__("pfield_linetoscr_normal_asm8");
  1700. extern void pfield_linetoscr_ehb_asm8(void) __asm__("pfield_linetoscr_ehb_asm8");
  1701. extern void pfield_linetoscr_ham6_asm8(void) __asm__("pfield_linetoscr_ham6_asm8");
  1702. extern void pfield_linetoscr_dualpf_asm8(void) __asm__("pfield_linetoscr_dualpf_asm8");
  1703. extern void pfield_linetoscr_hdouble_asm8(void) __asm__("pfield_linetoscr_hdouble_asm8");
  1704. extern void pfield_linetoscr_hdouble_dpf_asm8(void) __asm__("pfield_linetoscr_hdouble_dpf_asm8");
  1705. extern void pfield_linetoscr_hdouble_ehb_asm8(void) __asm__("pfield_linetoscr_hdouble_ehb_asm8");
  1706. extern void pfield_linetoscr_asm8(void (*)(void), int, int, int, int, ...) __asm__("pfield_linetoscr_asm8");
  1707.  
  1708. static void pfield_linetoscr_full8(int pix, int lframe_end, int diw_end, int stoppos)
  1709. {
  1710.     int lframe_end_1, diw_end_1;
  1711.  
  1712.     lframe_end_1 = pix + ((lframe_end - pix) & ~3);
  1713.     diw_end_1 = stoppos - ((stoppos - diw_end) & ~3);
  1714.  
  1715.     if (bplham && bplplanecnt == 6) {
  1716.     pfield_linetoscr_asm8(pfield_linetoscr_ham6_asm8, pix, lframe_end_1, diw_end_1, stoppos);
  1717.     } else if (bpldualpf) {
  1718. #ifdef LORES_HACK
  1719.     if (currprefs.gfx_lores == 2)
  1720.         pfield_linetoscr_asm8(pfield_linetoscr_hdouble_dpf_asm8, pix, lframe_end_1, diw_end_1, stoppos,
  1721.                    bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
  1722.     else
  1723. #endif
  1724.         pfield_linetoscr_asm8(pfield_linetoscr_dualpf_asm8, pix, lframe_end_1, diw_end_1, stoppos,
  1725.                   bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
  1726.     } else if (bplehb) {
  1727. #ifdef LORES_HACK
  1728.     if (currprefs.gfx_lores == 2)
  1729.         pfield_linetoscr_asm8(pfield_linetoscr_hdouble_ehb_asm8, pix, lframe_end_1, diw_end_1, stoppos);
  1730.     else
  1731. #endif
  1732.         pfield_linetoscr_asm8(pfield_linetoscr_ehb_asm8, pix, lframe_end_1, diw_end_1, stoppos);
  1733.     } else {
  1734. #ifdef LORES_HACK
  1735.     if (currprefs.gfx_lores == 2)
  1736.         pfield_linetoscr_asm8(pfield_linetoscr_hdouble_asm8, pix, lframe_end_1, diw_end_1, stoppos);
  1737.     else
  1738. #endif
  1739.         pfield_linetoscr_asm8(pfield_linetoscr_normal_asm8, pix, lframe_end_1, diw_end_1, stoppos);
  1740.     }
  1741.     
  1742.     /* The assembly functions work on aligned data, so we may have to do some
  1743.      * additional work at the edges. */
  1744.     if (lframe_end != lframe_end_1) {
  1745.     int i, c = colors_for_drawing.acolors[0];
  1746.     for (i = lframe_end_1; i < lframe_end; i++)
  1747.         xlinebuffer[i] = c;
  1748.     }
  1749.     if (diw_end != diw_end_1) {
  1750.     int i, c = colors_for_drawing.acolors[0];
  1751.     for (i = diw_end; i < diw_end_1; i++)
  1752.         xlinebuffer[i] = c;
  1753.     }
  1754. }
  1755.  
  1756. #undef pfield_linetoscr_full16
  1757. extern void pfield_linetoscr_normal_asm16(void) __asm__("pfield_linetoscr_normal_asm16");
  1758. extern void pfield_linetoscr_ehb_asm16(void) __asm__("pfield_linetoscr_ehb_asm16");
  1759. extern void pfield_linetoscr_ham6_asm16(void) __asm__("pfield_linetoscr_ham6_asm16");
  1760. extern void pfield_linetoscr_dualpf_asm16(void) __asm__("pfield_linetoscr_dualpf_asm16");
  1761. extern void pfield_linetoscr_hdouble_asm16(void) __asm__("pfield_linetoscr_hdouble_asm16");
  1762. extern void pfield_linetoscr_hdouble_dpf_asm16(void) __asm__("pfield_linetoscr_hdouble_dpf_asm16");
  1763. extern void pfield_linetoscr_hdouble_ehb_asm16(void) __asm__("pfield_linetoscr_hdouble_ehb_asm16");
  1764. extern void pfield_linetoscr_asm16(void (*)(void), int, int, int, int, ...) __asm__("pfield_linetoscr_asm16");
  1765.  
  1766. static void pfield_linetoscr_full16(int pix, int lframe_end, int diw_end, int stoppos)
  1767. {
  1768.     int lframe_end_1, diw_end_1;
  1769.  
  1770.     lframe_end_1 = pix + ((lframe_end - pix) & ~3);
  1771.     diw_end_1 = stoppos - ((stoppos - diw_end) & ~3);
  1772.  
  1773.     if (bplham && bplplanecnt == 6) {
  1774.     pfield_linetoscr_asm16(pfield_linetoscr_ham6_asm16, pix, lframe_end_1, diw_end_1, stoppos);
  1775.     } else if (bpldualpf) {
  1776. #ifdef LORES_HACK
  1777.     if (currprefs.gfx_lores == 2)
  1778.         pfield_linetoscr_asm16(pfield_linetoscr_hdouble_dpf_asm16, pix, lframe_end_1, diw_end_1, stoppos,
  1779.                    bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
  1780.     else
  1781. #endif
  1782.         pfield_linetoscr_asm16(pfield_linetoscr_dualpf_asm16, pix, lframe_end_1, diw_end_1, stoppos,
  1783.                    bpldualpfpri ? dblpf_ind2 : dblpf_ind1);
  1784.     } else if (bplehb) {
  1785. #ifdef LORES_HACK
  1786.     if (currprefs.gfx_lores == 2)
  1787.         pfield_linetoscr_asm16(pfield_linetoscr_hdouble_ehb_asm16, pix, lframe_end_1, diw_end_1, stoppos);
  1788.     else
  1789. #endif
  1790.         pfield_linetoscr_asm16(pfield_linetoscr_ehb_asm16, pix, lframe_end_1, diw_end_1, stoppos);
  1791.     } else {
  1792. #ifdef LORES_HACK
  1793.     if (currprefs.gfx_lores == 2)
  1794.         pfield_linetoscr_asm16(pfield_linetoscr_hdouble_asm16, pix, lframe_end_1, diw_end_1, stoppos);
  1795.     else
  1796. #endif
  1797.         pfield_linetoscr_asm16(pfield_linetoscr_normal_asm16, pix, lframe_end_1, diw_end_1, stoppos);
  1798.     }
  1799.  
  1800.     /* The assembly functions work on aligned data, so we may have to do some
  1801.      * additional work at the edges. */
  1802.     if (lframe_end != lframe_end_1) {
  1803.     int i, c = colors_for_drawing.acolors[0];
  1804.     for (i = lframe_end_1; i < lframe_end; i++)
  1805.         ((uae_u16 *)xlinebuffer)[i] = c;
  1806.     }
  1807.     if (diw_end != diw_end_1) {
  1808.     int i, c = colors_for_drawing.acolors[0];
  1809.     for (i = diw_end; i < diw_end_1; i++)
  1810.         ((uae_u16 *)xlinebuffer)[i] = c;
  1811.     }
  1812. }
  1813.  
  1814. #ifndef NO_DOUBLING_LINETOSCR
  1815. #define NO_DOUBLING_LINETOSCR
  1816. #endif
  1817.  
  1818. #endif
  1819.  
  1820. #ifdef NO_DOUBLING_LINETOSCR
  1821. #undef pfield_linetoscr_full8_double
  1822. #undef pfield_linetoscr_full16_double
  1823. static void pfield_linetoscr_full8_double(int start, int lframe_end, int diw_end, int stop)
  1824. {
  1825.     char *oldxlb = (char *)xlinebuffer;
  1826.     pfield_linetoscr_full8(start, lframe_end, diw_end, stop);
  1827.     xlinebuffer = oldxlb + linetoscr_double_offset;
  1828.     pfield_linetoscr_full8(start, lframe_end, diw_end, stop);
  1829. }
  1830. static void pfield_linetoscr_full16_double(int start, int lframe_end, int diw_end, int stop)
  1831. {
  1832.     char *oldxlb = (char *)xlinebuffer;
  1833.     pfield_linetoscr_full16(start, lframe_end, diw_end, stop);
  1834.     xlinebuffer = oldxlb + linetoscr_double_offset;
  1835.     pfield_linetoscr_full16(start, lframe_end, diw_end, stop);
  1836. }
  1837. #endif
  1838.  
  1839. static int linetoscr_diw_end, linetoscr_diw_start;
  1840.  
  1841. static void pfield_init_linetoscr (void)
  1842. {
  1843.     int ddf_left, ddf_right;
  1844.     int mindelay = bpldelay1, maxdelay = bpldelay2;
  1845.     if (bpldelay1 > bpldelay2)
  1846.     maxdelay = bpldelay1, mindelay = bpldelay2;
  1847.  
  1848.     linetoscr_diw_start = dp_for_drawing->diwfirstword;
  1849.     linetoscr_diw_end = dp_for_drawing->diwlastword;
  1850.  
  1851.     /* We should really look at DDF also when calculating max_diwstop/min_diwstrt,
  1852.      * so that centering works better, but I'm afraid that might cost too many
  1853.      * cycles. Plus it's dangerous, see the code below that handles the case 
  1854.      * with sprites. */
  1855.     if (dip_for_drawing->nr_sprites == 0) {
  1856.     int hiresadjust = bplhires ? 4 : 8;
  1857.     ddf_left = ((dp_for_drawing->plfstrt + hiresadjust)*2 + mindelay - DISPLAY_LEFT_SHIFT) << lores_shift;
  1858.     ddf_right = ((dp_for_drawing->plfstrt + dp_for_drawing->plflinelen + hiresadjust)*2 + maxdelay - DISPLAY_LEFT_SHIFT) << lores_shift;
  1859.     
  1860.     if (linetoscr_diw_start < ddf_left)
  1861.         linetoscr_diw_start = ddf_left;
  1862.     if (linetoscr_diw_end > ddf_right)
  1863.         linetoscr_diw_end = ddf_right;
  1864.  
  1865.     if (mindelay != maxdelay) {
  1866.         /* Raahh...
  1867.          * We just clear the maximum amount of space that may need to be
  1868.          * cleared. We could do this exactly, but it would come out slower
  1869.          * because of the overhead. */
  1870.         int strt = ddf_left;
  1871.         if (currprefs.gfx_lores == 2) {
  1872.         fuzzy_memset_le32 (pixdata.apixels, 0, (ddf_left>>1), 15);
  1873.         fuzzy_memset_le32 (pixdata.apixels, 0, (ddf_right>>1) - 15, 15);
  1874.         } else if (currprefs.gfx_lores) {
  1875.         fuzzy_memset_le32 (pixdata.apixels, 0, ddf_left, 15);
  1876.         fuzzy_memset_le32 (pixdata.apixels, 0, ddf_right - 15, 15);
  1877.         } else {
  1878.         fuzzy_memset_le32 (pixdata.apixels, 0, ddf_left, 30);
  1879.         fuzzy_memset_le32 (pixdata.apixels, 0, ddf_right - 30, 30);
  1880.         }
  1881.     }
  1882.     } else {
  1883.     int hiresadjust = bplhires ? 4 : 8;
  1884.     /* We swap mindelay and maxdelay here to get rid of the mindelay != maxdelay check.
  1885.      * Since we have to do a memset anyway (because there may be sprites),
  1886.      * we might as well clear all at once. */
  1887.     ddf_left = ((dp_for_drawing->plfstrt + hiresadjust)*2 + maxdelay - DISPLAY_LEFT_SHIFT) << lores_shift;
  1888.     ddf_right = ((dp_for_drawing->plfstrt + dp_for_drawing->plflinelen + hiresadjust)*2 + mindelay - DISPLAY_LEFT_SHIFT) << lores_shift;
  1889.     if (linetoscr_diw_start < ddf_left) {
  1890.         int strt = linetoscr_diw_start;
  1891.         int stop = ddf_left;
  1892. #ifdef LORES_HACK
  1893.         if (currprefs.gfx_lores == 2)
  1894.         strt >>= 1, stop >>= 1;
  1895. #endif
  1896.         if (strt < stop)
  1897.         fuzzy_memset (pixdata.apixels, 0, strt, stop - strt);
  1898.     }
  1899.  
  1900.     if (linetoscr_diw_end > ddf_right) {
  1901.         int strt = ddf_right;
  1902.         int stop = linetoscr_diw_end;
  1903. #ifdef LORES_HACK
  1904.         if (currprefs.gfx_lores == 2)
  1905.         strt >>= 1, stop >>= 1;
  1906. #endif
  1907.         if (strt < stop)
  1908.         fuzzy_memset (pixdata.apixels, 0, strt, stop - strt);
  1909.     }
  1910.     }
  1911.     /* Perverse cases happen. */
  1912.     if (linetoscr_diw_end < linetoscr_diw_start)
  1913.     linetoscr_diw_end = linetoscr_diw_start;
  1914. }
  1915.  
  1916. static void pfield_do_linetoscr(int start, int stop)
  1917. {
  1918.     int lframe_end = linetoscr_diw_start, diw_end = linetoscr_diw_end;
  1919.  
  1920.     if (stop > linetoscr_right_x)
  1921.     stop = linetoscr_right_x;
  1922.     if (start < linetoscr_x_adjust)
  1923.     start = linetoscr_x_adjust;
  1924.     
  1925.     if (lframe_end < start)
  1926.     lframe_end = start;
  1927.     if (diw_end > stop)
  1928.     diw_end = stop;
  1929.  
  1930.     if (start >= stop)
  1931.     return;
  1932.  
  1933. #if AGA_CHIPSET == 0
  1934.     if (start == linetoscr_x_adjust && stop == linetoscr_right_x) {
  1935.     switch (gfxvidinfo.pixbytes) {
  1936.      case 1: pfield_linetoscr_full8 (start, lframe_end, diw_end, stop); break;
  1937.      case 2: pfield_linetoscr_full16 (start, lframe_end, diw_end, stop); break;
  1938.      case 4: pfield_linetoscr_full32 (start, lframe_end, diw_end, stop); break;
  1939.     }
  1940.     } else {
  1941.     switch (gfxvidinfo.pixbytes) {
  1942.      case 1: pfield_linetoscr_8 (start, lframe_end, diw_end, stop); break;
  1943.      case 2: pfield_linetoscr_16 (start, lframe_end, diw_end, stop); break;
  1944.      case 4: pfield_linetoscr_32 (start, lframe_end, diw_end, stop); break;
  1945.     }
  1946.     }
  1947. #else
  1948.     pfield_linetoscr_aga(start, lframe_end, diw_end, stop);
  1949. #endif
  1950. }
  1951.  
  1952. static void pfield_do_fill_line(int start, int stop)
  1953. {
  1954.     if (stop > linetoscr_right_x)
  1955.     stop = linetoscr_right_x;
  1956.     if (start < linetoscr_x_adjust)
  1957.     start = linetoscr_x_adjust;
  1958.  
  1959.     if (start >= stop)
  1960.     return;
  1961.  
  1962.     switch (gfxvidinfo.pixbytes) {
  1963.      case 1: fill_line_8 (xlinebuffer, start, stop); break;
  1964.      case 2: fill_line_16 (xlinebuffer, start, stop); break;
  1965.      case 4: fill_line_32 (xlinebuffer, start, stop); break;
  1966.     }
  1967. }
  1968.  
  1969. static void pfield_do_linetoscr_full(int double_line)
  1970. {
  1971.     int start = linetoscr_x_adjust, stop = start + gfxvidinfo.maxlinetoscr;
  1972.     int lframe_end = linetoscr_diw_start, diw_end = linetoscr_diw_end;
  1973.     if (lframe_end < start)
  1974.     lframe_end = start;
  1975.     if (diw_end > stop)
  1976.     diw_end = stop;
  1977.  
  1978. #if AGA_CHIPSET == 0
  1979.     if (double_line) {
  1980.     switch (gfxvidinfo.pixbytes) {
  1981.      case 1: pfield_linetoscr_full8_double (start, lframe_end, diw_end, stop); break;
  1982.      case 2: pfield_linetoscr_full16_double (start, lframe_end, diw_end, stop); break;
  1983.      case 4: pfield_linetoscr_full32_double (start, lframe_end, diw_end, stop); break;
  1984.     }
  1985.     } else 
  1986.     switch (gfxvidinfo.pixbytes) {
  1987.      case 1: pfield_linetoscr_full8 (start, lframe_end, diw_end, stop); break;
  1988.      case 2: pfield_linetoscr_full16 (start, lframe_end, diw_end, stop); break;
  1989.      case 4: pfield_linetoscr_full32 (start, lframe_end, diw_end, stop); break;
  1990.     }
  1991. #else
  1992.     pfield_linetoscr_aga(start, lframe_end, diw_end, stop);
  1993. #endif
  1994. }
  1995.  
  1996.  /* 
  1997.   * register functions
  1998.   */
  1999.  
  2000. uae_u16 DMACONR(void)
  2001. {
  2002.     return (dmacon | (bltstate==BLT_done ? 0 : 0x4000)
  2003.         | (blt_info.blitzero ? 0x2000 : 0));
  2004. }
  2005. static uae_u16 INTENAR(void) { return intena; }
  2006. uae_u16 INTREQR(void)
  2007. {
  2008.     return intreq | (currprefs.use_serial ? 0x0001 : 0);
  2009. }
  2010. static uae_u16 ADKCONR(void) { return adkcon; }
  2011. static uae_u16 VPOSR(void) 
  2012. {
  2013. #if AGA_CHIPSET == 1
  2014.     return (vpos >> 8) | lof | 0x2300;
  2015. #elif defined (ECS_AGNUS)
  2016.     return (vpos >> 8) | lof | 0x2000;
  2017. #else
  2018.     return (vpos >> 8) | lof;
  2019. #endif
  2020. }
  2021. static void  VPOSW(uae_u16 v)
  2022. {
  2023.     if (lof != (v & 0x8000))
  2024.     lof_changed = 1;
  2025.     lof = v & 0x8000;
  2026. }
  2027. static uae_u16 VHPOSR(void) { return (vpos << 8) | current_hpos(); } 
  2028.  
  2029. static void  COP1LCH(uae_u16 v) { cop1lc= (cop1lc & 0xffff) | ((uae_u32)v << 16); }
  2030. static void  COP1LCL(uae_u16 v) { cop1lc= (cop1lc & ~0xffff) | v; }
  2031. static void  COP2LCH(uae_u16 v) { cop2lc= (cop2lc & 0xffff) | ((uae_u32)v << 16); }
  2032. static void  COP2LCL(uae_u16 v) { cop2lc= (cop2lc & ~0xffff) | v; }
  2033.  
  2034. static void  COPJMP1(uae_u16 a)
  2035. {
  2036.     coplc = cop1lc; copstate = COP_read; 
  2037.     eventtab[ev_copper].active = 1; eventtab[ev_copper].oldcycles = cycles;
  2038.     eventtab[ev_copper].evtime = 4 + cycles; events_schedule();
  2039.     copper_active = 1;
  2040.     copper_waiting_for_blitter = 0;
  2041. }
  2042. static void  COPJMP2(uae_u16 a)
  2043. {
  2044.     coplc = cop2lc; copstate = COP_read; 
  2045.     eventtab[ev_copper].active = 1; eventtab[ev_copper].oldcycles = cycles;
  2046.     eventtab[ev_copper].evtime = 4 + cycles; events_schedule();
  2047.     copper_active = 1;
  2048.     copper_waiting_for_blitter = 0;
  2049. }
  2050. static void  COPCON(uae_u16 a) { copcon = a; }
  2051. static void  DMACON(uae_u16 v) 
  2052. {
  2053.     int i, need_resched = 0;
  2054.  
  2055.     uae_u16 oldcon = dmacon;
  2056.     
  2057.     decide_line();
  2058.     setclr(&dmacon,v); dmacon &= 0x1FFF;
  2059.     post_decide_line ();
  2060.     
  2061.     /* FIXME? Maybe we need to think a bit more about the master DMA enable 
  2062.      * bit in these cases. */
  2063.     if ((dmacon & DMA_COPPER) > (oldcon & DMA_COPPER)) { 
  2064.     COPJMP1(0);
  2065.     }
  2066.     if ((dmacon & DMA_BLITPRI) > (oldcon & DMA_BLITPRI) && bltstate != BLT_done) {
  2067.     static int count = 0;
  2068.     if (!count) {
  2069.         count = 1;
  2070.         write_log ("warning: program is doing blitpri hacks.\n");
  2071.     }
  2072.     regs.spcflags |= SPCFLAG_BLTNASTY;
  2073.     }
  2074. #ifndef DONT_WANT_SOUND
  2075.     for (i = 0; i < 4; i++) {
  2076.     struct audio_channel_data *cdp = audio_channel + i;
  2077.     
  2078.     cdp->dmaen = (dmacon & 0x200) && (dmacon & (1<<i));
  2079.     if (cdp->dmaen) {
  2080.         if (cdp->state == 0) {
  2081.         cdp->state = 1;
  2082.         cdp->pt = cdp->lc;
  2083.         cdp->wper = cdp->per;
  2084.         cdp->wlen = cdp->len;
  2085.         cdp->data_written = 2;
  2086.         eventtab[ev_aud0 + i].oldcycles = eventtab[ev_hsync].oldcycles;
  2087.         eventtab[ev_aud0 + i].evtime = eventtab[ev_hsync].evtime;
  2088.         eventtab[ev_aud0 + i].active = 1;
  2089.         need_resched = 1; /* not _really_ necessary here, but... */
  2090.         }
  2091.     } else {
  2092.         if (cdp->state == 1 || cdp->state == 5) {
  2093.         cdp->state = 0;
  2094.         cdp->current_sample = 0;
  2095.         eventtab[ev_aud0 + i].active = 0;
  2096.         need_resched = 1;
  2097.         }
  2098.     }
  2099.     }
  2100. #endif
  2101.     calculate_copper_cycle_time ();
  2102.     if (copper_active && !eventtab[ev_copper].active) {
  2103.     eventtab[ev_copper].active = 1;
  2104.     eventtab[ev_copper].oldcycles = cycles;
  2105.     eventtab[ev_copper].evtime = 1 + cycles;
  2106.     need_resched = 1;
  2107.     }
  2108.     if (need_resched)
  2109.     events_schedule();
  2110. }
  2111.  
  2112. /*static int trace_intena = 0;*/
  2113.  
  2114. static void  INTENA(uae_u16 v) 
  2115. {
  2116. /*    if (trace_intena)
  2117.     fprintf(stderr, "INTENA: %04x\n", v);*/
  2118.     setclr(&intena,v); regs.spcflags |= SPCFLAG_INT; 
  2119. }
  2120. void  INTREQ(uae_u16 v)
  2121. {
  2122.     setclr(&intreq,v);
  2123.     regs.spcflags |= SPCFLAG_INT;
  2124.     if ((v&0x8800)==0x0800) serdat&=0xbfff;
  2125. }
  2126.  
  2127. static void  ADKCON(uae_u16 v) { setclr(&adkcon,v); }
  2128.  
  2129. static void  BPLPTH(uae_u16 v, int num) { decide_line (); decide_plane(); do_modulos(); bplpt[num] = (bplpt[num] & 0xffff) | ((uae_u32)v << 16); }
  2130. static void  BPLPTL(uae_u16 v, int num) { decide_line (); decide_plane(); do_modulos(); bplpt[num] = (bplpt[num] & ~0xffff) | (v & 0xFFFE); }
  2131.  
  2132. static void  BPLCON0(uae_u16 v)
  2133. {
  2134. #if AGA_CHIPSET == 0
  2135.     v &= 0xFF0E;
  2136.     /* The Sanity WOC demo needs this at one place (at the end of the "Party Effect")
  2137.      * Disable bitplane DMA if someone tries to do more than 4 Hires bitplanes. */
  2138.     if ((v & 0xF000) > 0xC000)
  2139.     v &= 0xFFF;
  2140.     /* Don't want 7 lores planes either. */
  2141.     if ((v & 0x8000) == 0 && (v & 0x7000) == 0x7000)
  2142.     v &= 0xEFFF;
  2143. #endif
  2144.     if (bplcon0 == v)
  2145.     return;
  2146.     decide_line ();
  2147.     bplcon0 = v;
  2148.     nr_planes_from_bplcon0 = (bplcon0 >> 12) & 7;
  2149.     corrected_nr_planes_from_bplcon0 = ((bplcon0 >> 12) & 7) << (bplcon0 & 0x8000 ? 1 : 0);
  2150.     post_decide_line ();
  2151.     calculate_copper_cycle_time ();
  2152. #if 0
  2153.     calcdiw(); /* This should go away. */
  2154. #endif
  2155. }
  2156. static void  BPLCON1(uae_u16 v) 
  2157. {
  2158.     if (bplcon1 == v)
  2159.     return;
  2160.     decide_diw ();
  2161.     bplcon1 = v;
  2162.     decide_delay ();
  2163. }
  2164. static void  BPLCON2(uae_u16 v) 
  2165. {
  2166.     if (bplcon2 != v)
  2167.     decide_line ();
  2168.     bplcon2 = v;
  2169. }
  2170. static void  BPLCON3(uae_u16 v) 
  2171. {
  2172.     if (bplcon3 != v)
  2173.     decide_line ();
  2174.     bplcon3 = v; 
  2175. }
  2176. static void  BPLCON4(uae_u16 v) 
  2177. {
  2178.     if (bplcon4 != v)
  2179.     decide_line ();
  2180.     bplcon4 = v; 
  2181. }
  2182.  
  2183. static void  BPL1MOD(uae_u16 v)
  2184. {
  2185.     v &= ~1;
  2186.     if ((uae_s16)bpl1mod == (uae_s16)v)
  2187.     return;
  2188.     bpl1mod = v;
  2189.     decide_modulos ();
  2190. }
  2191.  
  2192. static void  BPL2MOD(uae_u16 v)
  2193. { 
  2194.     v &= ~1;
  2195.     if ((uae_s16)bpl2mod == (uae_s16)v)
  2196.     return;
  2197.     bpl2mod = v;
  2198.     decide_modulos();
  2199. }
  2200.  
  2201. /* We could do as well without those... */
  2202. static void  BPL1DAT(uae_u16 v) { bpl1dat = v; }
  2203. static void  BPL2DAT(uae_u16 v) { bpl2dat = v; }
  2204. static void  BPL3DAT(uae_u16 v) { bpl3dat = v; }
  2205. static void  BPL4DAT(uae_u16 v) { bpl4dat = v; }
  2206. static void  BPL5DAT(uae_u16 v) { bpl5dat = v; }
  2207. static void  BPL6DAT(uae_u16 v) { bpl6dat = v; }
  2208.  
  2209. static void  DIWSTRT(uae_u16 v) 
  2210. {
  2211.     if (diwstrt == v)
  2212.     return;
  2213.     decide_line ();
  2214.     diwstrt = v; 
  2215.     calcdiw();
  2216. }
  2217. static void  DIWSTOP(uae_u16 v)
  2218. {
  2219.     if (diwstop == v)
  2220.     return;
  2221.     diwstop = v; 
  2222.     calcdiw();
  2223. }
  2224. static void  DDFSTRT(uae_u16 v)
  2225. { 
  2226.     v &= 0xFF;
  2227.     if (ddfstrt == v)
  2228.     return;
  2229.     decide_line ();
  2230.     ddfstrt = v; 
  2231.     calcdiw();
  2232. }
  2233. static void  DDFSTOP(uae_u16 v) 
  2234. { 
  2235.     v &= 0xFF;
  2236.     if (ddfstop == v)
  2237.     return;
  2238.     decide_line ();
  2239.     ddfstop = v;
  2240.     calcdiw();
  2241. }
  2242.  
  2243. static void  BLTADAT(uae_u16 v) 
  2244. {
  2245.     maybe_blit();
  2246.  
  2247.     blt_info.bltadat = v;
  2248. }
  2249. /*
  2250.  * "Loading data shifts it immediately" says the HRM. Well, that may
  2251.  * be true for BLTBDAT, but not for BLTADAT - it appears the A data must be
  2252.  * loaded for every word so that AFWM and ALWM can be applied.
  2253.  */
  2254. static void  BLTBDAT(uae_u16 v)
  2255. {
  2256.     maybe_blit(); 
  2257.  
  2258.     if (bltcon1 & 2)
  2259.     blt_info.bltbhold = v << (bltcon1 >> 12);
  2260.     else
  2261.     blt_info.bltbhold = v >> (bltcon1 >> 12);
  2262.     blt_info.bltbdat = v;
  2263. }
  2264. static void BLTCDAT(uae_u16 v) { maybe_blit(); blt_info.bltcdat = v; }
  2265.  
  2266. static void BLTAMOD(uae_u16 v) { maybe_blit(); blt_info.bltamod = (uae_s16)(v & 0xFFFE); }
  2267. static void BLTBMOD(uae_u16 v) { maybe_blit(); blt_info.bltbmod = (uae_s16)(v & 0xFFFE); }
  2268. static void BLTCMOD(uae_u16 v) { maybe_blit(); blt_info.bltcmod = (uae_s16)(v & 0xFFFE); }
  2269. static void BLTDMOD(uae_u16 v) { maybe_blit(); blt_info.bltdmod = (uae_s16)(v & 0xFFFE); }
  2270.  
  2271. static void BLTCON0(uae_u16 v) { maybe_blit(); bltcon0 = v; blinea_shift = v >> 12; }
  2272. /* The next category is "Most useless hardware register". 
  2273.  * And the winner is... */
  2274. static void BLTCON0L(uae_u16 v) { maybe_blit(); bltcon0 = (bltcon0 & 0xFF00) | (v & 0xFF); }
  2275. static void BLTCON1(uae_u16 v) { maybe_blit(); bltcon1 = v; }
  2276.  
  2277. static void BLTAFWM(uae_u16 v) { maybe_blit(); blt_info.bltafwm = v; }
  2278. static void BLTALWM(uae_u16 v) { maybe_blit(); blt_info.bltalwm = v; }
  2279.  
  2280. static void BLTAPTH(uae_u16 v) { maybe_blit(); bltapt= (bltapt & 0xffff) | ((uae_u32)v << 16); }
  2281. static void BLTAPTL(uae_u16 v) { maybe_blit(); bltapt= (bltapt & ~0xffff) | (v & 0xFFFE); }
  2282. static void BLTBPTH(uae_u16 v) { maybe_blit(); bltbpt= (bltbpt & 0xffff) | ((uae_u32)v << 16); }
  2283. static void BLTBPTL(uae_u16 v) { maybe_blit(); bltbpt= (bltbpt & ~0xffff) | (v & 0xFFFE); }
  2284. static void BLTCPTH(uae_u16 v) { maybe_blit(); bltcpt= (bltcpt & 0xffff) | ((uae_u32)v << 16); }
  2285. static void BLTCPTL(uae_u16 v) { maybe_blit(); bltcpt= (bltcpt & ~0xffff) | (v & 0xFFFE); }
  2286. static void BLTDPTH(uae_u16 v) { maybe_blit(); bltdpt= (bltdpt & 0xffff) | ((uae_u32)v << 16); }
  2287. static void BLTDPTL(uae_u16 v) { maybe_blit(); bltdpt= (bltdpt & ~0xffff) | (v & 0xFFFE); }
  2288. static void BLTSIZE(uae_u16 v) 
  2289. {
  2290.     bltsize = v;
  2291.     
  2292.     maybe_blit(); 
  2293.  
  2294.     blt_info.vblitsize = bltsize >> 6;
  2295.     blt_info.hblitsize = bltsize & 0x3F;
  2296.     if (!blt_info.vblitsize) blt_info.vblitsize = 1024;
  2297.     if (!blt_info.hblitsize) blt_info.hblitsize = 64;
  2298.     
  2299.     bltstate = BLT_init; 
  2300.     do_blitter();
  2301. }
  2302. static void BLTSIZV(uae_u16 v) 
  2303. {
  2304.     maybe_blit(); 
  2305.     oldvblts = v & 0x7FFF;
  2306. }
  2307. static void BLTSIZH(uae_u16 v)
  2308. {
  2309.     maybe_blit();
  2310.     blt_info.hblitsize = v & 0x7FF;
  2311.     blt_info.vblitsize = oldvblts;
  2312.     if (!blt_info.vblitsize) blt_info.vblitsize = 32768;
  2313.     if (!blt_info.hblitsize) blt_info.hblitsize = 0x800;
  2314.     bltstate = BLT_init;
  2315.     do_blitter();
  2316. }
  2317. static void SPRxCTL_1(uae_u16 v, int num)
  2318. {
  2319.     int sprxp;
  2320.     sprctl[num] = v;
  2321.     nr_armed -= sprarmed[num];
  2322.     sprarmed[num] = 0;
  2323.     if (sprpos[num] == 0 && v == 0) {
  2324.     sprst[num] = SPR_stop;
  2325.     spron[num] = 0;
  2326.     } else
  2327.     sprst[num] = SPR_waiting_start;
  2328.  
  2329.     sprxp = ((sprpos[num] & 0xFF) * 2) + (v & 1) - DISPLAY_LEFT_SHIFT;
  2330.     if (!currprefs.gfx_lores)
  2331.     sprxp *= 2;
  2332.     sprxpos[num] = sprxp;
  2333.     sprvstart[num] = (sprpos[num] >> 8) | ((sprctl[num] << 6) & 0x100);
  2334.     sprvstop[num] = (sprctl[num] >> 8) | ((sprctl[num] << 7) & 0x100);
  2335. }
  2336. static void SPRxPOS_1(uae_u16 v, int num) 
  2337. {
  2338.     int sprxp;
  2339.     sprpos[num] = v;
  2340.     sprxp = ((v & 0xFF) * 2) + (sprctl[num] & 1) - DISPLAY_LEFT_SHIFT;
  2341.     if (!currprefs.gfx_lores)
  2342.     sprxp *= 2;
  2343.     sprxpos[num] = sprxp;
  2344.     sprvstart[num] = (sprpos[num] >> 8) | ((sprctl[num] << 6) & 0x100);
  2345. }
  2346. static void SPRxDATA_1(uae_u16 v, int num)
  2347. {
  2348.     sprdata[num] = v;
  2349.     nr_armed += 1 - sprarmed[num];
  2350.     sprarmed[num] = 1;
  2351. }
  2352. static void SPRxDATB_1(uae_u16 v, int num)
  2353. {
  2354.     sprdatb[num] = v;
  2355. }
  2356. static void SPRxDATA(uae_u16 v, int num) { decide_sprites (); SPRxDATA_1 (v, num); }
  2357. static void SPRxDATB(uae_u16 v, int num) { decide_sprites (); SPRxDATB_1 (v, num); }
  2358. static void SPRxCTL(uae_u16 v, int num) { decide_sprites (); SPRxCTL_1 (v, num); }
  2359. static void SPRxPOS(uae_u16 v, int num) { decide_sprites (); SPRxPOS_1 (v, num); }
  2360. static void SPRxPTH(uae_u16 v, int num)
  2361. {
  2362.     decide_line ();
  2363.     sprpt[num] &= 0xffff; 
  2364.     sprpt[num] |= (uae_u32)v << 16;
  2365.  
  2366.     if (sprst[num] == SPR_stop)
  2367.     sprst[num] = SPR_restart;
  2368.     spron[num] = 1;
  2369. }
  2370. static void SPRxPTL(uae_u16 v, int num)
  2371. {
  2372.     decide_line ();
  2373.     sprpt[num] &= ~0xffff; 
  2374.     sprpt[num] |= v;
  2375.  
  2376.     if (sprst[num] == SPR_stop)
  2377.     sprst[num] = SPR_restart;
  2378.     spron[num] = 1;
  2379. }
  2380. static void CLXCON(uae_u16 v)
  2381. {
  2382.     clxcon = v;
  2383.     clx_sprmask = (((v >> 15) << 7) | ((v >> 14) << 5) | ((v >> 13) << 3) | ((v >> 12) << 1) | 0x55);
  2384. }
  2385. static uae_u16 CLXDAT(void)
  2386. {
  2387.     uae_u16 v = clxdat;
  2388.     clxdat = 0;
  2389.     return v;
  2390. }
  2391. static void COLOR(uae_u16 v, int num)
  2392. {
  2393.     int r,g,b;
  2394.     int cr,cg,cb;
  2395.     int colreg;
  2396.     
  2397.     v &= 0xFFF;
  2398. #if AGA_CHIPSET == 1
  2399.     {
  2400.     /* XXX Broken */
  2401.     uae_u32 cval;
  2402.     colreg = ((bplcon3 >> 13) & 7) * 32 + num;
  2403.     r = (v & 0xF00) >> 8;
  2404.     g = (v & 0xF0) >> 4;
  2405.     b = (v & 0xF) >> 0;
  2406.     cr = color_regs[colreg] >> 16;
  2407.     cg = (color_regs[colreg] >> 8) & 0xFF;
  2408.     cb = color_regs[colreg] & 0xFF;
  2409.  
  2410.     if (bplcon3 & 0x200) {
  2411.         cr &= 0xF0; cr |= r;
  2412.         cg &= 0xF0; cg |= g;
  2413.         cb &= 0xF0; cb |= b;
  2414.     } else {
  2415.         cr = r + (r << 4);
  2416.         cg = g + (g << 4);
  2417.         cb = b + (b << 4);
  2418.     }
  2419.     cval = (cr << 16) | (cg << 8) | cb;
  2420.     if (cval == color_regs[colreg])
  2421.         return;
  2422.     color_regs[colreg] = cval;
  2423.     pfield_may_need_update(1);
  2424.     }
  2425. #else 
  2426.     {
  2427.     if (current_colors.color_regs[num] == v)
  2428.         return;
  2429.     /* Call this with the old table still intact. */
  2430.     record_color_change (num, v);
  2431.     remembered_color_entry = -1;
  2432.     current_colors.color_regs[num] = v;
  2433.     current_colors.acolors[num] = xcolors[v];
  2434.     }
  2435. #endif
  2436. }
  2437.  
  2438. static void  DSKSYNC(uae_u16 v) { dsksync = v; }
  2439. static void  DSKDAT(uae_u16 v) { write_log ("DSKDAT written. Not good.\n"); }
  2440. static void  DSKPTH(uae_u16 v) { dskpt = (dskpt & 0xffff) | ((uae_u32)v << 16); }
  2441. static void  DSKPTL(uae_u16 v) { dskpt = (dskpt & ~0xffff) | (v); }
  2442.  
  2443. static void  DSKLEN(uae_u16 v) 
  2444. {
  2445.     if (v & 0x8000) {
  2446.     dskdmaen = dskdmaen == 1 ? 2 : 1;
  2447.     } else { 
  2448.     dskdmaen = 0;
  2449.     if (eventtab[ev_diskblk].active)
  2450.         write_log ("warning: Disk DMA aborted!\n");
  2451.     eventtab[ev_diskblk].active = 0;
  2452.     events_schedule();
  2453.     
  2454.     }
  2455.     dsklen = dsklength = v; dsklength &= 0x3fff;
  2456.     if (dskdmaen == 2 && dsksync != 0x4489 && (adkcon & 0x400)) {
  2457.     sprintf (warning_buffer, "Non-standard sync: %04x len: %x\n", dsksync, dsklength);
  2458.     write_log (warning_buffer);
  2459.     }
  2460.     if (dskdmaen > 1) {
  2461.     if (dsklen & 0x4000) {
  2462.         eventtab[ev_diskblk].active = 1;
  2463.         eventtab[ev_diskblk].oldcycles = cycles;
  2464.         eventtab[ev_diskblk].evtime = 40 + cycles; /* ??? */
  2465.         events_schedule();
  2466.     } else {
  2467.         int result = DISK_PrepareReadMFM(dsklength, dsksync, adkcon & 0x400);
  2468.         if (result) {
  2469.         eventtab[ev_diskblk].active = 1;
  2470.         eventtab[ev_diskblk].oldcycles = cycles;
  2471.         eventtab[ev_diskblk].evtime = result + cycles;
  2472.         events_schedule();
  2473.         }
  2474.     }
  2475.     }
  2476. }
  2477.  
  2478. static uae_u16 DSKBYTR(void)
  2479. {
  2480.     uae_u16 v = (dsklen >> 1) & 0x6000;
  2481.     uae_u16 mfm, byte;
  2482.     if (DISK_GetData(&mfm, &byte))
  2483.     v |= 0x8000;
  2484.     v |= byte;
  2485.     if (dsksync == mfm) v |= 0x1000;
  2486.     return v;
  2487. }
  2488.  
  2489. static uae_u16 DSKDATR(void) 
  2490. {
  2491.     uae_u16 mfm, byte;
  2492.     DISK_GetData(&mfm, &byte);
  2493.     return mfm; 
  2494. }
  2495. static uae_u16 POTGOR(void)
  2496. {
  2497.     uae_u16 v = 0xFF00;
  2498.     if (JSEM_ISMOUSE (0, currprefs.fake_joystick)) {
  2499.     if (buttonstate[2])
  2500.         v &= 0xFBFF;
  2501.  
  2502.     if (buttonstate[1])
  2503.         v &= 0xFEFF;
  2504.     }
  2505.     else if (JSEM_ISJOY0(0, currprefs.fake_joystick) || JSEM_ISJOY1(0, currprefs.fake_joystick)) {
  2506.         if (joy0button & 2) v &= 0xfbff;
  2507.         if (joy0button & 4) v &= 0xfeff;
  2508.     }
  2509.  
  2510.     if (JSEM_ISJOY0(1, currprefs.fake_joystick) || JSEM_ISJOY1(1, currprefs.fake_joystick)) {
  2511.         if (joy1button & 2) v &= 0xbfff;
  2512.         if (joy1button & 4) v &= 0xefff;
  2513.     }
  2514.         
  2515.     return v;
  2516. }
  2517. static uae_u16 POT0DAT(void)
  2518. {
  2519.     static uae_u16 cnt = 0;
  2520.     if (JSEM_ISMOUSE (0, currprefs.fake_joystick)) {
  2521.     if (buttonstate[2])
  2522.         cnt = ((cnt + 1) & 0xFF) | (cnt & 0xFF00);
  2523.     if (buttonstate[1])
  2524.         cnt += 0x100;
  2525.     }
  2526.  
  2527.     return cnt;
  2528. }
  2529. static uae_u16 JOY0DAT(void)
  2530. {
  2531.     if (JSEM_ISMOUSE (0, currprefs.fake_joystick)) {
  2532.     return ((uae_u8)mouse_x) + ((uae_u16)mouse_y << 8);
  2533.     }
  2534.     return joy0dir;
  2535. }
  2536. static uae_u16 JOY1DAT(void)
  2537. {
  2538.     if (JSEM_ISMOUSE (1, currprefs.fake_joystick)) {
  2539.     return ((uae_u8)mouse_x) + ((uae_u16)mouse_y << 8);
  2540.     }
  2541.     return joy1dir;
  2542. }
  2543. static void JOYTEST(uae_u16 v)
  2544. {
  2545.     if (JSEM_ISMOUSE (0, currprefs.fake_joystick)) {
  2546.     mouse_x = v & 0xFC;
  2547.     mouse_y = (v >> 8) & 0xFC;
  2548.     }
  2549. }
  2550. static void AUDxLCH(int nr, uae_u16 v) { audio_channel[nr].lc = (audio_channel[nr].lc & 0xffff) | ((uae_u32)v << 16); }
  2551. static void AUDxLCL(int nr, uae_u16 v) { audio_channel[nr].lc = (audio_channel[nr].lc & ~0xffff) | (v & 0xFFFE); }
  2552. static void AUDxPER(int nr, uae_u16 v)
  2553. {
  2554.     if (v <= 0) {
  2555. #if 0 /* v == 0 is rather common, and harmless, and the value isn't signed anyway */
  2556.     static int warned = 0;
  2557.     if (!warned)
  2558.         write_log ("Broken program accessing the sound hardware\n"), warned++;
  2559. #endif
  2560.     v = 65535;
  2561.     }
  2562.     if (v < maxhpos/2 && currprefs.produce_sound < 3)
  2563.     v = maxhpos/2;
  2564.  
  2565.     audio_channel[nr].per = v;
  2566. }
  2567.  
  2568. static void AUDxVOL(int nr, uae_u16 v) { audio_channel[nr].vol = v & 64 ? 63 : v & 63; }
  2569. static void AUDxLEN(int nr, uae_u16 v) { audio_channel[nr].len = v; }
  2570.  
  2571. /*
  2572.  * Here starts the copper code. It should be rewritten.
  2573.  */
  2574.  
  2575. #define COPPER_ALTERNATIVE 1
  2576. /*
  2577.  * Calculate the minimum number of cycles after which the
  2578.  * copper comparison becomes true. This is quite tricky. I hope it works.
  2579.  */
  2580. static int calc_copcomp_true(int currvpos, int currhpos)
  2581. {    
  2582.     uae_u16 vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  2583.     uae_u16 hp = currhpos & (copi2 & 0xFE);
  2584.     uae_u16 vcmp = ((copi1 & (copi2 | 0x8000)) >> 8);
  2585.     uae_u16 hcmp = (copi1 & copi2 & 0xFE);
  2586.     int copper_time_hpos;
  2587.     int cycleadd = maxhpos - currhpos;
  2588.     int coptime = 0;
  2589.     int maxwait = 32767;
  2590.  
  2591. #if COPPER_ALTERNATIVE == 0
  2592.     /* This is a kludge... the problem is that there are programs that wait for
  2593.      * FFDDFFFE and then for a line in the second display half, and this doesn't
  2594.      * work without this. I _think_ the reason why it works on the Amiga is that
  2595.      * the last cycle in the line isn't available for the copper, but I'm not sure.
  2596.      * OTOH, I'm pretty convinced that the copper timings are correct otherwise, so
  2597.      * I added this rather than changing something else. */
  2598.     if (hcmp == 0xDC)
  2599.     hcmp += 2;
  2600. #endif
  2601.     if ((vp > vcmp || (vp == vcmp && hp >= hcmp)) && ((copi2 & 0x8000) || !(DMACONR() & 0x4000)))
  2602.         return 0;    
  2603.  
  2604.     try_again:
  2605.  
  2606.     while (vp < vcmp) {
  2607.     currvpos++;
  2608.     if (currvpos > maxvpos + 1)
  2609.         return -1;
  2610.     currhpos = 0;
  2611.     coptime += cycleadd;
  2612.     cycleadd = maxhpos;
  2613.     vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  2614.     }
  2615.     if ((bplcon0 & 0xF000) == 0xC000) {
  2616.     if (coptime > 0)
  2617.         return coptime;
  2618.     maxwait = plfstrt - current_hpos();
  2619.     if (maxwait < 0)
  2620.         maxwait = 32767;
  2621.     }
  2622.     copper_time_hpos = currhpos;
  2623.     hp = copper_time_hpos & (copi2 & 0xFE);
  2624.     if (!(vp > vcmp)) {    
  2625.     while ((int)hp < ((int)hcmp)) {
  2626.         currhpos++;
  2627.         /* Copper DMA is turned off in Hires 4 bitplane mode */
  2628.         if (decided_nr_planes != 4 /* -1 if before plfstrt */
  2629.         || !decided_hires
  2630.         || current_hpos () >= (thisline_decision.plfstrt + thisline_decision.plflinelen))
  2631.         copper_time_hpos++;
  2632.         
  2633.         if (currhpos > maxhpos) {
  2634.         /* Now, what? There might be a good position on the
  2635.          * next line. But it can also be the FFFF FFFE
  2636.          * case.
  2637.          */
  2638.         currhpos = 0;
  2639.         currvpos++;
  2640.         vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  2641.         goto try_again;
  2642.         }
  2643.         coptime++;
  2644.         if (coptime >= maxwait)
  2645.         return coptime;
  2646.         hp = copper_time_hpos & (copi2 & 0xFE);
  2647.     }
  2648.     }
  2649.     if (coptime == 0) /* waiting for the blitter */
  2650.         return 1;
  2651.  
  2652.     return coptime;
  2653. }
  2654.  
  2655. /*
  2656.  * Simple version of the above which only tries to get vpos correct.
  2657.  */
  2658. static int calc_copcomp_true_vpos(int currvpos, int currhpos)
  2659. {    
  2660.     uae_u16 vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  2661.     uae_u16 hp = currhpos & (copi2 & 0xFE);
  2662.     uae_u16 vcmp = ((copi1 & (copi2 | 0x8000)) >> 8);
  2663.     uae_u16 hcmp = (copi1 & copi2 & 0xFE);
  2664.     int copper_time_hpos;
  2665.     int cycleadd = maxhpos - currhpos;
  2666.     int coptime = 0;
  2667. #if COPPER_ALTERNATIVE == 0
  2668.     /* see above */
  2669.     if (hcmp == 0xDC)
  2670.     hcmp += 2;
  2671. #endif
  2672.     if ((vp > vcmp || (vp == vcmp && hp >= hcmp)) && ((copi2 & 0x8000) || !(DMACONR() & 0x4000)))
  2673.         return 0;    
  2674.  
  2675.     while (vp < vcmp) {
  2676.     currvpos++;
  2677.     if (currvpos > maxvpos + 1)
  2678.         return -1;
  2679.     currhpos = 0;
  2680.     coptime += cycleadd;
  2681.     cycleadd = maxhpos;
  2682.     vp = currvpos & (((copi2 >> 8) & 0x7F) | 0x80);
  2683.     }
  2684.     return coptime;
  2685. }
  2686.  
  2687. static enum copper_states cop_cmds[4] = { COP_move, COP_wait, COP_move, COP_skip };
  2688.  
  2689. /* This function is not always correct, but it's the best we can do. */
  2690. static int copper_memory_cycles (int n)
  2691. {
  2692.     int current_cycle = current_hpos ();
  2693.     int n_needed = 0;
  2694.     int planes = corrected_nr_planes_from_bplcon0;
  2695.  
  2696.     while (n) {
  2697.     /* This sucks. The DIW may end vertically at exactly this point. Therefore,
  2698.      * we must call decide_line(). If we're vertically outside the DIW,
  2699.      * copper_cycle_time will be != -1 after this call [Sanity Interference] */
  2700.     decide_line ();
  2701. #if COPPER_ALTERNATIVE == 1
  2702.     if (current_cycle >= (maxhpos-3)) {
  2703.         n_needed += maxhpos - current_cycle;
  2704.         current_cycle = 0;
  2705.         continue;
  2706.     }
  2707. #endif
  2708.     if (copper_cycle_time == -1 && current_cycle >= 0x14 
  2709.         && current_cycle >= plfstrt && current_cycle < plfstrt + plflinelen
  2710.         && (planes == 6 || (planes == 5 && (current_cycle % 8) < 4)))
  2711.     {
  2712.         n_needed += 4;
  2713.         current_cycle += 4;
  2714.     } else {
  2715.         n_needed += 2;
  2716.         current_cycle += 2;        
  2717.     }
  2718.     if (current_cycle >= maxhpos)
  2719.         current_cycle -= maxhpos;
  2720.     n--;
  2721.     }
  2722.     return n_needed;
  2723. }
  2724.  
  2725. static __inline__ int calc_copper_cycles (int n_cycles)
  2726. {
  2727.     return /*copper_cycle_time != -1 ? copper_cycle_time * n_cycles : */copper_memory_cycles (n_cycles);
  2728. }
  2729.  
  2730. static __inline__ int copper_init_read (int n_cycles)
  2731. {
  2732.     if (dmaen(DMA_COPPER)){
  2733.     int t = calc_copper_cycles (n_cycles);
  2734.  
  2735.     eventtab[ev_copper].evtime = t + cycles;
  2736.     return 1;
  2737.     } else {
  2738.     copstate = COP_read;
  2739.     eventtab[ev_copper].active = 0;
  2740.     return 0;
  2741.     }
  2742. }
  2743.  
  2744. static __inline__ void copper_read (void)
  2745. {
  2746.     int cmd;
  2747.     
  2748.     copi1 = chipmem_bank.wget(coplc); 
  2749.     copi2 = chipmem_bank.wget(coplc+2);
  2750.     coplc += 4;
  2751.     eventtab[ev_copper].oldcycles = cycles;
  2752.     
  2753.     cmd = (copi1 & 1) | ((copi2 & 1) << 1);
  2754.     copstate = cop_cmds[cmd];
  2755.     eventtab[ev_copper].oldcycles = cycles;
  2756. }
  2757.  
  2758. static __inline__ void handle_bltfinish_wait (void)
  2759. {
  2760.     if (bltstate == BLT_done) {
  2761.     copstate = COP_read;
  2762.     /* Don't need to wait. Experimental: No copper wakeup time in this case. */
  2763.     } else {
  2764.     eventtab[ev_copper].active = 0;
  2765.     copstate = COP_morewait;
  2766.     copper_waiting_for_blitter = 1;
  2767.     }
  2768. }
  2769.  
  2770. void blitter_done_notify (void)
  2771. {
  2772.     if (copper_waiting_for_blitter) {
  2773.     copper_waiting_for_blitter = 0;
  2774.     eventtab[ev_copper].active = 1;
  2775.     eventtab[ev_copper].oldcycles = cycles;
  2776.     eventtab[ev_copper].evtime = 1 + cycles;
  2777.     events_schedule ();
  2778.     }
  2779. }
  2780.  
  2781. static void do_copper_cheat(void)
  2782. {
  2783.     int coptime, t;
  2784.     int nmoves = 100; /*??*/
  2785.     int nextcycles = eventtab[ev_hsync].evtime + currprefs.copper_pos;
  2786.  
  2787.     eventtab[ev_copper].evtime = nextcycles;
  2788.     eventtab[ev_copper].oldcycles = cycles;
  2789.     nextcycles -= cycles;
  2790.  
  2791.     if (!dmaen(DMA_COPPER)) {
  2792.     eventtab[ev_copper].active = 0;
  2793.     return;
  2794.     }
  2795.     for (; nmoves; nmoves--)
  2796.     switch(copstate){
  2797.      case COP_read:
  2798.         copper_read ();
  2799.         break;
  2800.  
  2801.      case COP_read_ignore:
  2802.         copper_read ();
  2803.         copstate = COP_read;
  2804.         break;
  2805.  
  2806.      case COP_move:
  2807.         if (copi1 >= (copcon & 2 ? 0x40u : 0x80u)) {
  2808.         custom_bank.wput(copi1,copi2);
  2809.         copstate = COP_read;
  2810.         } else {
  2811.         copstate = COP_stop;
  2812.         eventtab[ev_copper].active = 0;
  2813.         copper_active = 0;
  2814.         return;
  2815.         }
  2816.         break;
  2817.  
  2818.      case COP_skip:
  2819.         copstate = COP_read;
  2820.         if (calc_copcomp_true(vpos, current_hpos()) == 0)
  2821.         copstate = COP_read_ignore;
  2822.         break;
  2823.  
  2824.      case COP_wait:
  2825.         coptime = calc_copcomp_true(vpos, current_hpos());
  2826.         if (coptime < 0) {
  2827.         copstate = COP_stop;
  2828.         eventtab[ev_copper].active = 0;
  2829.         copper_active = 0;
  2830.         return;
  2831.         }
  2832.         if (coptime == 0) {
  2833.         copper_read();
  2834.         if (vpos != 255)
  2835.             break;
  2836.         eventtab[ev_copper].evtime = cycles + 6;
  2837.         return;
  2838.         }
  2839.         if (coptime >= nextcycles)
  2840.         return;
  2841.         if (vpos == 255)
  2842.         eventtab[ev_copper].evtime = cycles + coptime;
  2843.         /*else
  2844.         copstate = COP_read;*/
  2845.         return;
  2846.  
  2847.      case COP_stop:
  2848.         eventtab[ev_copper].active = 0;
  2849.         copper_active = 0;
  2850.         return;
  2851.         
  2852.      case COP_morewait:
  2853.      case COP_do_read:
  2854.      case COP_do_read_ignore:
  2855.         abort();
  2856.     }
  2857. }
  2858.  
  2859. static void do_copper(void)
  2860. {
  2861.     int coptime, t;
  2862.     for (;;)
  2863.     switch(copstate){
  2864.      case COP_read:
  2865.         eventtab[ev_copper].oldcycles = cycles;
  2866.         if (!copper_init_read (2))
  2867.         return;
  2868.         copstate = COP_do_read;
  2869.         return;
  2870.     
  2871.      case COP_do_read:
  2872.         copper_read ();
  2873.         break;
  2874.  
  2875.      case COP_read_ignore:
  2876.         eventtab[ev_copper].oldcycles = cycles;
  2877.         if (!copper_init_read (2))
  2878.         return;
  2879.         copstate = COP_do_read_ignore;
  2880.         return;
  2881.  
  2882.      case COP_do_read_ignore:
  2883.         copper_read ();
  2884.         copstate = COP_read;
  2885.         break;
  2886.  
  2887.      case COP_move:
  2888.         if (copi1 >= (copcon & 2 ? 0x40u : 0x80u)) {
  2889.         custom_bank.wput(copi1,copi2);
  2890.         copstate = COP_read;
  2891.         break;
  2892.         } else {
  2893.         copstate = COP_stop;
  2894.         eventtab[ev_copper].active = 0;
  2895.         copper_active = 0;
  2896.         }
  2897.         return;
  2898.  
  2899.      case COP_skip:
  2900.         copstate = COP_read;
  2901.         if (calc_copcomp_true(vpos, current_hpos()) == 0)
  2902.         copstate = COP_read_ignore;
  2903.         break;
  2904.  
  2905.      case COP_wait:
  2906.         /* Recognize blitter wait statements. This is a speed optimization
  2907.          * only.*/
  2908.         if (copi1 == 1 && copi2 == 0) {
  2909.         handle_bltfinish_wait ();
  2910.         if (!eventtab[ev_copper].active)
  2911.             return;
  2912.         break;
  2913.         }
  2914.         coptime = calc_copcomp_true_vpos(vpos, current_hpos());
  2915.         if (coptime > 0) {
  2916.         copstate = COP_morewait;
  2917.         eventtab[ev_copper].oldcycles = cycles;
  2918.         eventtab[ev_copper].evtime = coptime + cycles;
  2919.         return;
  2920.         }
  2921.         coptime = calc_copcomp_true(vpos, current_hpos());
  2922.         if (coptime < 0) {
  2923.         copstate = COP_stop;
  2924.         eventtab[ev_copper].active = 0;
  2925.         copper_active = 0;
  2926.         return;
  2927.         }
  2928.         if (coptime) {
  2929.         copstate = COP_morewait;
  2930.         eventtab[ev_copper].evtime = coptime + cycles;
  2931.         return;
  2932.         }
  2933.         copstate = COP_read;
  2934.         /* Experimental: no copper wakeup time in this case. The HRM says
  2935.          * nothing about this. */
  2936.         break;
  2937.  
  2938.      case COP_morewait:
  2939.         coptime = calc_copcomp_true(vpos, current_hpos());
  2940.         if (coptime < 0) {
  2941.         copstate = COP_stop;
  2942.         eventtab[ev_copper].active = 0;
  2943.         copper_active = 0;
  2944.         return;
  2945.         }
  2946.         if (coptime) {
  2947.         eventtab[ev_copper].evtime = coptime + cycles;
  2948.         return;
  2949.         }
  2950.         /* Copper wakeup time: 1 memory cycle, plus 2 for the next read */
  2951.         eventtab[ev_copper].oldcycles = cycles;
  2952.         if (!copper_init_read (3))
  2953.         return;
  2954.         copstate = COP_do_read;
  2955.         return;
  2956.  
  2957.      case COP_stop:
  2958.         eventtab[ev_copper].active = 0;
  2959.         copper_active = 0;
  2960.         return;
  2961.     }
  2962. }
  2963.  
  2964. static void diskblk_handler(void)
  2965. {
  2966.     regs.spcflags |= SPCFLAG_DISK;
  2967.     eventtab[ev_diskblk].active = 0;
  2968. }
  2969.  
  2970. void do_disk(void)
  2971. {
  2972.     if (dskdmaen != 2 && (regs.spcflags & SPCFLAG_DISK)) {
  2973.     static int warned = 0;
  2974.     if (!warned)
  2975.         warned++, write_log ("BUG!\n");
  2976.     return;
  2977.     }
  2978.     if (dmaen(0x10)){
  2979.     if (dsklen & 0x4000) {
  2980.         if (!chipmem_bank.check (dskpt, 2*dsklength)) {
  2981.         write_log ("warning: Bad disk write DMA pointer\n");
  2982.         } else {
  2983.         uae_u8 *mfmp = get_real_address (dskpt);
  2984.         int i;
  2985.         DISK_InitWrite();
  2986.  
  2987.         for (i = 0; i < dsklength; i++) {
  2988.             uae_u16 d = (*mfmp << 8) + *(mfmp+1);
  2989.             mfmwrite[i] = d;
  2990.             mfmp += 2;
  2991.         }
  2992.         DISK_WriteData(dsklength);
  2993.         }
  2994.     } else {
  2995.         int result = DISK_ReadMFM (dskpt);
  2996.     }
  2997.     regs.spcflags &= ~SPCFLAG_DISK;
  2998.     INTREQ(0x9002);
  2999.     dskdmaen = -1;
  3000.     }
  3001. }
  3002.  
  3003. static void gen_pfield_tables(void)
  3004. {
  3005.     int i;
  3006.     union {
  3007.     struct {
  3008.         uae_u8 a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p;
  3009.     } foo;
  3010.     struct {
  3011.         uae_u32 a, b, c, d;
  3012.     } bar;
  3013.     } baz;
  3014.     
  3015.     for (i = 0; i < 256; i++) {
  3016.     /* We lose every second pixel in HiRes if UAE runs in a 320x200 screen. */
  3017.     baz.foo.a = i & 64 ? 1 : 0;
  3018.     baz.foo.b = i & 16 ? 1 : 0;
  3019.     baz.foo.c = i & 4 ? 1 : 0;
  3020.     baz.foo.d = i & 1 ? 1 : 0;
  3021.     hirestab_l[i][0] = baz.bar.a;
  3022.     
  3023.     baz.foo.a = i & 128 ? 1 : 0;
  3024.     baz.foo.b = i & 64 ? 1 : 0;
  3025.     baz.foo.c = i & 32 ? 1 : 0;
  3026.     baz.foo.d = i & 16 ? 1 : 0;
  3027.     baz.foo.e = i & 8 ? 1 : 0;
  3028.     baz.foo.f = i & 4 ? 1 : 0;
  3029.     baz.foo.g = i & 2 ? 1 : 0;
  3030.     baz.foo.h = i & 1 ? 1 : 0;
  3031.     lorestab_l[i][0] = baz.bar.a;
  3032.     lorestab_l[i][1] = baz.bar.b;
  3033.     sprtaba[i] = ((((i >> 7) & 1) << 0)
  3034.               | (((i >> 6) & 1) << 2)
  3035.               | (((i >> 5) & 1) << 4)
  3036.               | (((i >> 4) & 1) << 6)
  3037.               | (((i >> 3) & 1) << 8)
  3038.               | (((i >> 2) & 1) << 10)
  3039.               | (((i >> 1) & 1) << 12)
  3040.               | (((i >> 0) & 1) << 14));
  3041.     sprtabb[i] = sprtaba[i] * 2;
  3042.     clxtab[i] = ((((i & 3) && (i & 12)) << 9)
  3043.              | (((i & 3) && (i & 48)) << 10)
  3044.              | (((i & 3) && (i & 192)) << 11)
  3045.              | (((i & 12) && (i & 48)) << 12)
  3046.              | (((i & 12) && (i & 192)) << 13)
  3047.              | (((i & 48) && (i & 192)) << 14));
  3048.     }
  3049.     
  3050.     for (i = 0; i < 256; i++) {
  3051.     baz.foo.a = i & 128 ? 1 : 0;
  3052.     baz.foo.b = i & 64 ? 1 : 0;
  3053.     baz.foo.c = i & 32 ? 1 : 0;
  3054.     baz.foo.d = i & 16 ? 1 : 0;
  3055.     baz.foo.e = i & 8 ? 1 : 0;
  3056.     baz.foo.f = i & 4 ? 1 : 0;
  3057.     baz.foo.g = i & 2 ? 1 : 0;
  3058.     baz.foo.h = i & 1 ? 1 : 0;
  3059.     hirestab_h[i][0] = baz.bar.a;
  3060.     hirestab_h[i][1] = baz.bar.b;
  3061.     
  3062.     baz.foo.a = i & 128 ? 1 : 0;
  3063.     baz.foo.b = i & 128 ? 1 : 0;
  3064.     baz.foo.c = i & 64 ? 1 : 0;
  3065.     baz.foo.d = i & 64 ? 1 : 0;
  3066.     baz.foo.e = i & 32 ? 1 : 0;
  3067.     baz.foo.f = i & 32 ? 1 : 0;
  3068.     baz.foo.g = i & 16 ? 1 : 0;
  3069.     baz.foo.h = i & 16 ? 1 : 0;
  3070.     baz.foo.i = i & 8 ? 1 : 0;
  3071.     baz.foo.j = i & 8 ? 1 : 0;
  3072.     baz.foo.k = i & 4 ? 1 : 0;
  3073.     baz.foo.l = i & 4 ? 1 : 0;
  3074.     baz.foo.m = i & 2 ? 1 : 0;
  3075.     baz.foo.n = i & 2 ? 1 : 0;
  3076.     baz.foo.o = i & 1 ? 1 : 0;
  3077.     baz.foo.p = i & 1 ? 1 : 0;
  3078.     lorestab_h[i][0] = baz.bar.a;
  3079.     lorestab_h[i][1] = baz.bar.b;
  3080.     lorestab_h[i][2] = baz.bar.c;
  3081.     lorestab_h[i][3] = baz.bar.d;
  3082.     }
  3083. }
  3084.  
  3085. static void do_sprites(int currvp, int currhp)
  3086. {   
  3087.     int i;
  3088.     /* The graph in the HRM, p. 195 seems to indicate that sprite 0 is
  3089.      * fetched at cycle 0x14 and thus can't be disabled by bitplane DMA. */
  3090.     int maxspr = currhp/4 - 0x14/4;
  3091. #if 0
  3092.     if (currvp == 0)
  3093.     return;
  3094. #else 
  3095.     /* I don't know whether this is right. Some programs write the sprite pointers
  3096.      * directly at the start of the copper list. With the currvp==0 check, the
  3097.      * first two words of data are read on the second line in the frame. The problem
  3098.      * occurs when the program jumps to another copperlist a few lines further down
  3099.      * which _also_ writes the sprite pointer registers. This means that a) writing
  3100.      * to the sprite pointers sets the state to SPR_restart; or b) that sprite DMA
  3101.      * is disabled until the end of the vertical blanking interval. The HRM
  3102.      * isn't clear - it says that the vertical sprite position can be set to any
  3103.      * value, but this wouldn't be the first mistake... */
  3104.     /* Update: I modified one of the programs to write the sprite pointers the 
  3105.      * second time only _after_ the VBlank interval, and it showed the same behaviour
  3106.      * as it did unmodified under UAE with the above check. This indicates that the
  3107.      * solution below is correct. */
  3108.     if (currvp < vblank_endline)
  3109.     return;
  3110. #endif
  3111.     if (maxspr < 0)
  3112.     return;
  3113.     if (maxspr > 8)
  3114.     maxspr = 8;
  3115.  
  3116.     for (i = 0; i < maxspr; i++) {
  3117.     int fetch = 0;
  3118.  
  3119.     if (spron[i] == 0)
  3120.         continue;
  3121.  
  3122.     if (sprst[i] == SPR_restart) {
  3123.         fetch = 2;
  3124.         spron[i] = 1;
  3125.     } else if ((sprst[i] == SPR_waiting_start && sprvstart[i] == vpos) || sprst[i] == SPR_waiting_stop) {
  3126.         fetch = 1;
  3127.         sprst[i] = SPR_waiting_stop;
  3128.     }
  3129.     if (sprst[i] == SPR_waiting_stop && sprvstop[i] == vpos) {
  3130.         fetch = 2;
  3131.         sprst[i] = SPR_waiting_start;
  3132.     }
  3133.  
  3134.     if (fetch && dmaen(DMA_SPRITE)) {
  3135.         uae_u16 data1 = chipmem_bank.wget(sprpt[i]);
  3136.         uae_u16 data2 = chipmem_bank.wget(sprpt[i]+2);
  3137.         sprpt[i] += 4;
  3138.         
  3139.         if (fetch == 1) {
  3140.         /* Hack for X mouse auto-calibration */
  3141.         if (i == 0 && !sprvbfl && ((sprpos[0] & 0xff) << 2) > 2 * DISPLAY_LEFT_SHIFT) {
  3142.             spr0ctl=sprctl[0];
  3143.             spr0pos=sprpos[0];
  3144.             sprvbfl=2;
  3145.         }
  3146.         SPRxDATB_1(data2, i);
  3147.         SPRxDATA_1(data1, i);
  3148.         } else {
  3149.         SPRxPOS_1(data1, i);
  3150.         SPRxCTL_1(data2, i);
  3151.         }
  3152.     }
  3153.     }
  3154. }
  3155.  
  3156. static uae_u32 attach_2nd;
  3157.  
  3158. static uae_u32 do_sprite_collisions (struct sprite_draw *spd, int prev_overlap, int i, int nr_spr)
  3159. {
  3160.     int j;
  3161.     int sprxp = spd[i].linepos;
  3162.     uae_u32 datab = spd[i].datab;
  3163.     uae_u32 mask2 = 0;
  3164.     int sbit = 1 << spd[i].num;
  3165.     int sprx_shift = 1;
  3166.     int attach_compare = -1;
  3167.     if (currprefs.gfx_lores != 1)
  3168.     sprx_shift = 0;
  3169.  
  3170.     attach_2nd = 0;
  3171.     if ((spd[i].num & 1) == 1 && (spd[i].ctl & 0x80) == 0x80)
  3172.     attach_compare = spd[i].num - 1;
  3173.  
  3174.     for (j = prev_overlap; j < i; j++) {
  3175.     uae_u32 mask1;
  3176.     int off;
  3177.     
  3178.     if (spd[i].num < spd[j].num)
  3179.         continue;
  3180.  
  3181.     off = sprxp - spd[j].linepos;
  3182.     off <<= sprx_shift;
  3183.     mask1 = spd[j].datab >> off;
  3184.  
  3185.     /* If j is an attachment for i, then j doesn't block i */
  3186.     if (spd[j].num == attach_compare) {
  3187.         attach_2nd |= mask1;
  3188.     } else {
  3189.         mask1 |= (mask1 & 0xAAAAAAAA) >> 1;
  3190.         mask1 |= (mask1 & 0x55555555) << 1;
  3191.         if (datab & mask1)
  3192.         clxdat |= clxtab[(sbit | (1 << spd[j].num)) & clx_sprmask];
  3193.         mask2 |= mask1;
  3194.     }
  3195.     }
  3196.     for (j = i+1; j < nr_spr; j++) {
  3197.     uae_u32 mask1;
  3198.     int off = spd[j].linepos - sprxp;
  3199.  
  3200.     if (off >= sprite_width || spd[i].num < spd[j].num)
  3201.         break;
  3202.  
  3203.     off <<= sprx_shift;
  3204.     mask1 = spd[j].datab << off;
  3205.  
  3206.     /* If j is an attachment for i, then j doesn't block i */
  3207.     if (spd[j].num == attach_compare) {
  3208.         attach_2nd |= mask1;
  3209.     } else {
  3210.         mask1 |= (mask1 & 0xAAAAAAAA) >> 1;
  3211.         mask1 |= (mask1 & 0x55555555) << 1;
  3212.         if (datab & mask1)
  3213.         clxdat |= clxtab[(sbit | (1 << spd[j].num)) & clx_sprmask];
  3214.         mask2 |= mask1;
  3215.     }
  3216.     }
  3217.     datab &= ~mask2;
  3218.     return datab;
  3219. }
  3220.  
  3221. static __inline__ void render_sprite (int spr, int sprxp, uae_u32 datab, int ham, int attch, int sprx_inc)
  3222. {
  3223.     uae_u32 datcd;
  3224.     int basecol = 16;
  3225.     if (!attch)
  3226.     basecol += (spr & ~1)*2;
  3227.     if (bpldualpf)
  3228.     basecol |= 128;
  3229.     if (attch)
  3230.     datcd = attach_2nd;
  3231.  
  3232.     for(; attch ? datab | datcd : datab; sprxp += sprx_inc) {
  3233.     int col;
  3234.  
  3235.     if (attch) {
  3236.         col = ((datab & 3) << 2) | (datcd & 3);
  3237.         datcd >>= 2;
  3238.     } else
  3239.         col = datab & 3;
  3240.     datab >>= 2;
  3241.     if (col) {
  3242.         col |= basecol;
  3243.         if (ham) {
  3244.         col = colors_for_drawing.color_regs[col];
  3245.         ham_linebuf[sprxp] = col;
  3246.         if (sprx_inc == 2) {
  3247.             ham_linebuf[sprxp+1] = col;
  3248.         }
  3249.         } else {
  3250.         pixdata.apixels[sprxp] = col;
  3251.         if (sprx_inc == 2) {
  3252.             pixdata.apixels[sprxp+1] = col;
  3253.         }
  3254.         }
  3255.     }
  3256.     }
  3257. }
  3258.  
  3259. static void walk_sprites (struct sprite_draw *spd, int nr_spr)
  3260. {
  3261.     int i, prev_overlap;
  3262.     int last_sprite_pos = -64;
  3263.     uae_u32 plane1 = 0, plane2 = 0;
  3264.     int sprx_inc = 1, sprx_shift = 1;
  3265.     
  3266.     if (currprefs.gfx_lores == 0)
  3267.     sprx_inc = 2, sprx_shift = 0;
  3268.  
  3269.     prev_overlap = 0;
  3270.     for (i = 0; i < nr_spr; i++) {
  3271.     int sprxp = spd[i].linepos;
  3272.     int m = 1 << spd[i].num;
  3273.     uae_u32 datab;
  3274.     while (prev_overlap < i && spd[prev_overlap].linepos + sprite_width <= sprxp)
  3275.         prev_overlap++;
  3276.     
  3277.     datab = do_sprite_collisions (spd, prev_overlap, i, nr_spr);
  3278. #ifdef LORES_HACK
  3279.     if (currprefs.gfx_lores == 2)
  3280.         sprxp >>= 1;
  3281. #endif
  3282.     if ((bpldualpf && plfpri[1] < 256) || (plfpri[2] < 256)) {
  3283.         if (sprxp != last_sprite_pos) {
  3284.         int ok = last_sprite_pos-sprxp+16;
  3285.         int ok2;
  3286.         if (ok <= 0) {
  3287.             ok = ok2 = 0;
  3288.             plane1 = 0;
  3289.             plane2 = 0;
  3290.         } else {
  3291.             ok2 = ok << sprx_shift;
  3292.             plane1 >>= 32 - ok2;
  3293.             plane2 >>= 32 - ok2;
  3294.         }
  3295.         last_sprite_pos = sprxp;
  3296.  
  3297.         if (bpldualpf) {
  3298.             uae_u32 mask = 3 << ok2;
  3299.             int p = sprxp+ok;
  3300.  
  3301.             for (; mask; mask <<= 2, p += sprx_inc) {
  3302.             int data = pixdata.apixels[p];
  3303.             if (dblpf_2nd2[data] == 2)
  3304.                 plane2 |= mask;
  3305.             if (dblpf_2nd1[data] == 1)
  3306.                 plane1 |= mask;
  3307.             }
  3308.         } else {
  3309.             uae_u32 mask = 3 << ok2;
  3310.             int p = sprxp+ok;
  3311.  
  3312.             for (; mask; mask <<= 2, p += sprx_inc) {
  3313.             if (pixdata.apixels[p])
  3314.                 plane2 |= mask;
  3315.             }
  3316.         }
  3317.         }
  3318.         if (bpldualpf && m >= plfpri[1]) {
  3319.         datab &= ~plane1;
  3320.         attach_2nd &= ~plane1;
  3321.         }
  3322.         if (m >= plfpri[2]) {
  3323.         datab &= ~plane2;
  3324.         attach_2nd &= ~plane2;
  3325.         }
  3326.     }
  3327.     if ((spd[i].num & 1) == 1 && (spd[i].ctl & 0x80) == 0x80) {
  3328.         /* Attached sprite */
  3329.         if (bplham) {
  3330.         if (sprx_inc == 1) {
  3331.             render_sprite (spd[i].num, sprxp, datab, 1, 1, 1);
  3332.         } else {
  3333.             render_sprite (spd[i].num, sprxp, datab, 1, 1, 2);
  3334.         }
  3335.         } else {
  3336.         if (sprx_inc == 1) {
  3337.             render_sprite (spd[i].num, sprxp, datab, 0, 1, 1);
  3338.         } else {
  3339.             render_sprite (spd[i].num, sprxp, datab, 0, 1, 2);
  3340.         }
  3341.         }
  3342.         /* This still leaves one attached sprite bug, but at the moment I'm too lazy */
  3343.         if (i + 1 < nr_spr && spd[i+1].num == spd[i].num - 1 && spd[i+1].linepos == spd[i].linepos)
  3344.         i++;
  3345.     } else {
  3346.         if (bplham) {
  3347.         if (sprx_inc == 1) {
  3348.             render_sprite (spd[i].num, sprxp, datab, 1, 0, 1);
  3349.         } else {
  3350.             render_sprite (spd[i].num, sprxp, datab, 1, 0, 2);
  3351.         }
  3352.         } else {
  3353.         if (sprx_inc == 1) {
  3354.             render_sprite (spd[i].num, sprxp, datab, 0, 0, 1);
  3355.         } else {
  3356.             render_sprite (spd[i].num, sprxp, datab, 0, 0, 2);
  3357.         }
  3358.         }
  3359.     }
  3360.     }
  3361. }
  3362.  
  3363. #ifndef SMART_UPDATE
  3364. #undef UNALIGNED_PROFITABLE
  3365. #endif
  3366.  
  3367. #ifdef UNALIGNED_PROFITABLE
  3368. /*
  3369.  * Be sure to pass a constant for the third and fourth parameters to get proper optimization.
  3370.  */
  3371. static __inline__ void doop_planes_hires_unaligned_h (uae_u32 *app, uae_u8 *ptr, int nplanes, int do_or)
  3372. {
  3373.     int i;
  3374.     int len = dp_for_drawing->plflinelen >> 1;
  3375.     for (i = 0; i < len; i++) {
  3376.     unsigned int data1;
  3377.     uae_u32 v1, v2;
  3378.  
  3379.     data1 = *(ptr + i);
  3380.     v1 = hirestab_h[data1][0];
  3381.     v2 = hirestab_h[data1][1];
  3382.  
  3383.     if (nplanes > 1) {
  3384.         unsigned int data2 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3385.         v1 |= hirestab_h[data2][0] << 2;
  3386.         v2 |= hirestab_h[data2][1] << 2;
  3387.     }
  3388.     if (nplanes > 2) {
  3389.         unsigned int data3 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3390.         v1 |= hirestab_h[data3][0] << 4;
  3391.         v2 |= hirestab_h[data3][1] << 4;
  3392.     }
  3393.     if (nplanes > 3) {
  3394.         unsigned int data4 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3395.         v1 |= hirestab_h[data4][0] << 6;
  3396.         v2 |= hirestab_h[data4][1] << 6;
  3397.     }
  3398.     if (do_or) {
  3399.         app[i*2] |= v1 << 1;
  3400.         app[i*2 + 1] |= v2 << 1;
  3401.     } else {
  3402.         app[i*2] = v1;
  3403.         app[i*2 + 1] = v2;
  3404.     }
  3405.     }
  3406. }
  3407.  
  3408. static __inline__ void doop_planes_lores_unaligned_h (uae_u32 *app, uae_u8 *ptr, int nplanes, int do_or)
  3409. {
  3410.     int i;
  3411.     int len = dp_for_drawing->plflinelen >> 2;
  3412.     for (i = 0; i < len; i++) {
  3413.     unsigned int data1;
  3414.     uae_u32 v1, v2, v3, v4;
  3415.  
  3416.     data1 = *(ptr + i);
  3417.     v1 = lorestab_h[data1][0];
  3418.     v2 = lorestab_h[data1][1];
  3419.     v3 = lorestab_h[data1][2];
  3420.     v4 = lorestab_h[data1][3];
  3421.  
  3422.     if (nplanes > 1) {
  3423.         unsigned int data2 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3424.         v1 |= lorestab_h[data2][0] << 2;
  3425.         v2 |= lorestab_h[data2][1] << 2;
  3426.         v3 |= lorestab_h[data2][2] << 2;
  3427.         v4 |= lorestab_h[data2][3] << 2;
  3428.     }
  3429.  
  3430.     if (nplanes > 2) {
  3431.         unsigned int data3 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3432.         v1 |= lorestab_h[data3][0] << 4;
  3433.         v2 |= lorestab_h[data3][1] << 4;
  3434.         v3 |= lorestab_h[data3][2] << 4;
  3435.         v4 |= lorestab_h[data3][3] << 4;
  3436.     }
  3437.  
  3438.     if (nplanes > 3) {
  3439.         unsigned int data4 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3440.         v1 |= lorestab_h[data4][0] << 6;
  3441.         v2 |= lorestab_h[data4][1] << 6;
  3442.         v3 |= lorestab_h[data4][2] << 6;
  3443.         v4 |= lorestab_h[data4][3] << 6;
  3444.     }
  3445.     if (do_or) {
  3446.         app[i*4] |= v1 << 1;
  3447.         app[i*4 + 1] |= v2 << 1;
  3448.         app[i*4 + 2] |= v3 << 1;
  3449.         app[i*4 + 3] |= v4 << 1;
  3450.     } else {
  3451.         app[i*4] = v1;
  3452.         app[i*4 + 1] = v2;
  3453.         app[i*4 + 2] = v3;
  3454.         app[i*4 + 3] = v4;
  3455.     }
  3456.     }
  3457. }
  3458.  
  3459. static __inline__ void doop_planes_hires_unaligned_l (uae_u32 *app, uae_u8 *ptr, int nplanes, int do_or)
  3460. {
  3461.     int i;
  3462.     int len = dp_for_drawing->plflinelen >> 1;
  3463.     for (i = 0; i < len; i++) {
  3464.     unsigned int data1;
  3465.     uae_u32 v;
  3466.  
  3467.     data1 = *(ptr + i);
  3468.     v = hirestab_l[data1][0];
  3469.     if (nplanes > 1) {
  3470.         unsigned int data2 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3471.         v |= hirestab_l[data2][0] << 2;
  3472.     }
  3473.     if (nplanes > 2) {
  3474.         unsigned int data3 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3475.         v |= hirestab_l[data3][0] << 4;
  3476.     }
  3477.     if (nplanes > 3) {
  3478.         unsigned int data4 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);    
  3479.         v |= hirestab_l[data4][0] << 6;
  3480.     }
  3481.     if (do_or)
  3482.         app[i] |= v << 1;
  3483.     else
  3484.         app[i] = v;
  3485.     }
  3486. }
  3487.  
  3488. static __inline__ void doop_planes_lores_unaligned_l (uae_u32 *app, uae_u8 *ptr, int nplanes, int do_or)
  3489. {
  3490.     int i;
  3491.     int len = dp_for_drawing->plflinelen >> 2;
  3492.     for (i = 0; i < len; i++) {
  3493.     unsigned int data1;
  3494.     uae_u32 v1, v2;
  3495.  
  3496.     data1 = *(ptr + i);
  3497.     v1 = lorestab_l[data1][0];
  3498.     v2 = lorestab_l[data1][1];
  3499.  
  3500.     if (nplanes > 1) {
  3501.         unsigned int data2 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3502.         v1 |= lorestab_l[data2][0] << 2;
  3503.         v2 |= lorestab_l[data2][1] << 2;
  3504.     }
  3505.     if (nplanes > 2) {
  3506.         unsigned int data3 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3507.         v1 |= lorestab_l[data3][0] << 4;
  3508.         v2 |= lorestab_l[data3][1] << 4;
  3509.     }
  3510.     if (nplanes > 3) {
  3511.         unsigned int data4 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3512.         v1 |= lorestab_l[data4][0] << 6;
  3513.         v2 |= lorestab_l[data4][1] << 6;
  3514.     }
  3515.     if (do_or) {
  3516.         app[i*2] |= v1 << 1;
  3517.         app[i*2 + 1] |= v2 << 1;
  3518.     } else {
  3519.         app[i*2] = v1;
  3520.         app[i*2 + 1] = v2;
  3521.     }
  3522.     }
  3523. }
  3524.  
  3525. static __inline__ void set_planes_hires_unaligned_h (uae_u32 *app, uae_u8 *ptr, int nplanes)
  3526. {
  3527.     int i;
  3528.     int len = dp_for_drawing->plflinelen >> 1;
  3529.     for (i = 0; i < len; i++) {
  3530.     unsigned int data1;
  3531.     uae_u32 v1, v2;
  3532.  
  3533.     data1 = *(ptr + i);
  3534.     v1 = hirestab_h[data1][0];
  3535.     v2 = hirestab_h[data1][1];
  3536.  
  3537.     if (nplanes > 1) { 
  3538.         unsigned int data2 = *(ptr + i + 1*MAX_WORDS_PER_LINE*2);
  3539.         v1 |= hirestab_h[data2][0] << 1;
  3540.         v2 |= hirestab_h[data2][1] << 1;
  3541.     }
  3542.  
  3543.     if (nplanes > 2) { 
  3544.         unsigned int data3 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3545.         v1 |= hirestab_h[data3][0] << 2;
  3546.         v2 |= hirestab_h[data3][1] << 2;
  3547.     }
  3548.  
  3549.     if (nplanes > 3) { 
  3550.         unsigned int data4 = *(ptr + i + 3*MAX_WORDS_PER_LINE*2);
  3551.         v1 |= hirestab_h[data4][0] << 3;
  3552.         v2 |= hirestab_h[data4][1] << 3;
  3553.     }
  3554.  
  3555.     if (nplanes > 4) { 
  3556.         unsigned int data5 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3557.         v1 |= hirestab_h[data5][0] << 4;
  3558.         v2 |= hirestab_h[data5][1] << 4;
  3559.     }
  3560.  
  3561.     if (nplanes > 5) { 
  3562.         unsigned int data6 = *(ptr + i + 5*MAX_WORDS_PER_LINE*2);
  3563.         v1 |= hirestab_h[data6][0] << 5;
  3564.         v2 |= hirestab_h[data6][1] << 5;
  3565.     }
  3566.  
  3567.     if (nplanes > 6) { 
  3568.         unsigned int data7 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3569.         v1 |= hirestab_h[data7][0] << 6;
  3570.         v2 |= hirestab_h[data7][1] << 6;
  3571.     }
  3572.  
  3573.     if (nplanes > 7) { 
  3574.         unsigned int data8 = *(ptr + i + 7*MAX_WORDS_PER_LINE*2);    
  3575.          v1 |= hirestab_h[data8][0] << 7;
  3576.          v2 |= hirestab_h[data8][1] << 7;
  3577.     }
  3578.     app[i*2] = v1;
  3579.     app[i*2 + 1] = v2;
  3580.     }
  3581. }
  3582.  
  3583. static __inline__ void set_planes_lores_unaligned_h (uae_u32 *app, uae_u8 *ptr, int nplanes)
  3584. {
  3585.     int i;
  3586.     int len = dp_for_drawing->plflinelen >> 2;
  3587.     for (i = 0; i < len; i++) {
  3588.     unsigned int data1;
  3589.     uae_u32 v1, v2, v3, v4;
  3590.  
  3591.     data1 = *(ptr + i);
  3592.     v1 = lorestab_h[data1][0];
  3593.     v2 = lorestab_h[data1][1];
  3594.     v3 = lorestab_h[data1][2];
  3595.     v4 = lorestab_h[data1][3];
  3596.  
  3597.     if (nplanes > 1) { 
  3598.         unsigned int data2 = *(ptr + i + 1*MAX_WORDS_PER_LINE*2);
  3599.         v1 |= lorestab_h[data2][0] << 1;
  3600.         v2 |= lorestab_h[data2][1] << 1;
  3601.         v3 |= lorestab_h[data2][2] << 1;
  3602.         v4 |= lorestab_h[data2][3] << 1;
  3603.     }
  3604.  
  3605.     if (nplanes > 2) {
  3606.         unsigned int data3 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3607.         v1 |= lorestab_h[data3][0] << 2;
  3608.         v2 |= lorestab_h[data3][1] << 2;
  3609.         v3 |= lorestab_h[data3][2] << 2;
  3610.         v4 |= lorestab_h[data3][3] << 2;
  3611.     }
  3612.  
  3613.     if (nplanes > 3) {
  3614.         unsigned int data4 = *(ptr + i + 3*MAX_WORDS_PER_LINE*2);
  3615.         v1 |= lorestab_h[data4][0] << 3;
  3616.         v2 |= lorestab_h[data4][1] << 3;
  3617.         v3 |= lorestab_h[data4][2] << 3;
  3618.         v4 |= lorestab_h[data4][3] << 3;
  3619.     }
  3620.  
  3621.     if (nplanes > 4) { 
  3622.         unsigned int data5 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3623.         v1 |= lorestab_h[data5][0] << 4;
  3624.         v2 |= lorestab_h[data5][1] << 4;
  3625.         v3 |= lorestab_h[data5][2] << 4;
  3626.         v4 |= lorestab_h[data5][3] << 4;
  3627.     }
  3628.  
  3629.     if (nplanes > 5) {
  3630.         unsigned int data6 = *(ptr + i + 5*MAX_WORDS_PER_LINE*2);
  3631.         v1 |= lorestab_h[data6][0] << 5;
  3632.         v2 |= lorestab_h[data6][1] << 5;
  3633.         v3 |= lorestab_h[data6][2] << 5;
  3634.         v4 |= lorestab_h[data6][3] << 5;
  3635.     }
  3636.  
  3637.     if (nplanes > 6) {
  3638.         unsigned int data7 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3639.         v1 |= lorestab_h[data7][0] << 6;
  3640.         v2 |= lorestab_h[data7][1] << 6;
  3641.         v3 |= lorestab_h[data7][2] << 6;
  3642.         v4 |= lorestab_h[data7][3] << 6;
  3643.     }
  3644.  
  3645.     if (nplanes > 7) {
  3646.         unsigned int data8 = *(ptr + i + 7*MAX_WORDS_PER_LINE*2);
  3647.         v1 |= lorestab_h[data8][0] << 7;
  3648.         v2 |= lorestab_h[data8][1] << 7;
  3649.         v3 |= lorestab_h[data8][2] << 7;
  3650.         v4 |= lorestab_h[data8][3] << 7;
  3651.     }
  3652.     app[i*4] = v1;
  3653.     app[i*4 + 1] = v2;
  3654.     app[i*4 + 2] = v3;
  3655.     app[i*4 + 3] = v4;
  3656.     }
  3657. }
  3658.  
  3659. static __inline__ void set_planes_hires_unaligned_l (uae_u32 *app, uae_u8 *ptr, int nplanes)
  3660. {
  3661.     int i;
  3662.     int len = dp_for_drawing->plflinelen >> 1;
  3663.     for (i = 0; i < len; i++) {
  3664.     unsigned int data1;
  3665.     uae_u32 v;
  3666.  
  3667.     data1 = *(ptr + i);
  3668.     
  3669.     v = hirestab_l[data1][0];
  3670.     if (nplanes > 1) {
  3671.         unsigned int data2 = *(ptr + i + 1*MAX_WORDS_PER_LINE*2);
  3672.         v |= hirestab_l[data2][0] << 1;
  3673.     }
  3674.     if (nplanes > 2) {
  3675.         unsigned int data3 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3676.         v |= hirestab_l[data3][0] << 2;
  3677.     }
  3678.     if (nplanes > 3) {
  3679.         unsigned int data4 = *(ptr + i + 3*MAX_WORDS_PER_LINE*2);
  3680.         v |= hirestab_l[data4][0] << 3;
  3681.     }
  3682.     if (nplanes > 4) {
  3683.         unsigned int data5 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3684.         v |= hirestab_l[data5][0] << 4;
  3685.     }
  3686.     if (nplanes > 5) {
  3687.         unsigned int data6 = *(ptr + i + 5*MAX_WORDS_PER_LINE*2);
  3688.         v |= hirestab_l[data6][0] << 5;
  3689.     }
  3690.     if (nplanes > 6) {
  3691.         unsigned int data7 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3692.         v |= hirestab_l[data7][0] << 6;
  3693.     }
  3694.     if (nplanes > 7) {
  3695.         unsigned int data8 = *(ptr + i + 7*MAX_WORDS_PER_LINE*2);
  3696.         v |= hirestab_l[data8][0] << 7;
  3697.     }
  3698.     app[i] = v;
  3699.     }
  3700. }
  3701.  
  3702. static __inline__ void set_planes_lores_unaligned_l (uae_u32 *app, uae_u8 *ptr, int nplanes)
  3703. {
  3704.     int i;
  3705.     int len = dp_for_drawing->plflinelen >> 2;
  3706.     for (i = 0; i < len; i++) {
  3707.     unsigned int data1;
  3708.     uae_u32 v1, v2;
  3709.  
  3710.     data1 = *(ptr + i);
  3711.     v1 = lorestab_l[data1][0];
  3712.     v2 = lorestab_l[data1][1];
  3713.  
  3714.     if (nplanes > 1) {
  3715.         unsigned int data2 = *(ptr + i + 1*MAX_WORDS_PER_LINE*2);
  3716.         v1 |= lorestab_l[data2][0] << 1;
  3717.         v2 |= lorestab_l[data2][1] << 1;
  3718.     }
  3719.  
  3720.     if (nplanes > 2) {
  3721.         unsigned int data3 = *(ptr + i + 2*MAX_WORDS_PER_LINE*2);
  3722.         v1 |= lorestab_l[data3][0] << 2;
  3723.         v2 |= lorestab_l[data3][1] << 2;
  3724.     }
  3725.  
  3726.     if (nplanes > 3) {
  3727.         unsigned int data4 = *(ptr + i + 3*MAX_WORDS_PER_LINE*2);
  3728.         v1 |= lorestab_l[data4][0] << 3;
  3729.         v2 |= lorestab_l[data4][1] << 3;
  3730.     }
  3731.  
  3732.     if (nplanes > 4) {
  3733.         unsigned int data5 = *(ptr + i + 4*MAX_WORDS_PER_LINE*2);
  3734.         v1 |= lorestab_l[data5][0] << 4;
  3735.         v2 |= lorestab_l[data5][1] << 4;
  3736.     }
  3737.  
  3738.     if (nplanes > 5) {
  3739.         unsigned int data6 = *(ptr + i + 5*MAX_WORDS_PER_LINE*2);    
  3740.         v1 |= lorestab_l[data6][0] << 5;
  3741.         v2 |= lorestab_l[data6][1] << 5;
  3742.     }
  3743.  
  3744.     if (nplanes > 6) {
  3745.         unsigned int data7 = *(ptr + i + 6*MAX_WORDS_PER_LINE*2);
  3746.         v1 |= lorestab_l[data7][0] << 6;
  3747.         v2 |= lorestab_l[data7][1] << 6;
  3748.     }
  3749.     
  3750.     if (nplanes > 7) {
  3751.         unsigned int data8 = *(ptr + i + 7*MAX_WORDS_PER_LINE*2);
  3752.         v1 |= lorestab_l[data8][0] << 7;
  3753.         v2 |= lorestab_l[data8][1] << 7;
  3754.     }
  3755.  
  3756.     app[i*2] = v1;
  3757.     app[i*2 + 1] = v2;
  3758.     }
  3759. }
  3760.  
  3761. static void pfield_doline_unaligned_h (int lineno)
  3762. {
  3763.     int xpos = dp_for_drawing->plfstrt * 4 - DISPLAY_LEFT_SHIFT * 2;
  3764.     
  3765.     if (bplhires) {
  3766.     int xpos1 = xpos + 16 + bpldelay1*2;
  3767.     int xpos2;
  3768.     uae_u8 *dataptr = line_data[lineno];
  3769.     
  3770.     if (bpldelay1 == bpldelay2) {
  3771.         switch (bplplanecnt) {
  3772.          case 1: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1); break;
  3773.          case 2: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2); break;
  3774.          case 3: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3); break;
  3775.          case 4: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4); break;
  3776.          case 5: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 5); break;
  3777.          case 6: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 6); break;
  3778.          case 7: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 7); break;
  3779.          case 8: set_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 8); break;
  3780.         }
  3781.     } else {
  3782.         switch (bplplanecnt) {
  3783.          case 1: case 2: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1, 0); break;
  3784.          case 3: case 4: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2, 0); break;
  3785.          case 5: case 6: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3, 0); break;
  3786.          case 7: case 8: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4, 0); break;
  3787.         }
  3788.  
  3789.         dataptr += MAX_WORDS_PER_LINE*2;
  3790.         xpos2 = xpos + 16 + bpldelay2*2;
  3791.         switch (bplplanecnt) {
  3792.          case 2: case 3: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 1, 1); break;
  3793.          case 4: case 5: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 2, 1); break;
  3794.          case 6: case 7: doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 3, 1); break;
  3795.          case 8:         doop_planes_hires_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 4, 1); break;
  3796.         }
  3797.     }
  3798.     } else {
  3799.     int xpos1 = xpos + 32 + bpldelay1*2;
  3800.     int xpos2;
  3801.     uae_u8 *dataptr = line_data[lineno];
  3802.  
  3803.     if (bpldelay1 == bpldelay2) {
  3804.         switch (bplplanecnt) {
  3805.          case 1: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1); break;
  3806.          case 2: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2); break;
  3807.          case 3: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3); break;
  3808.          case 4: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4); break;
  3809.          case 5: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 5); break;
  3810.          case 6: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 6); break;
  3811.          case 7: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 7); break;
  3812.          case 8: set_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 8); break;
  3813.         }
  3814.     } else {
  3815.         switch (bplplanecnt) {
  3816.          case 1: case 2: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1, 0); break;
  3817.          case 3: case 4: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2, 0); break;
  3818.          case 5: case 6: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3, 0); break;
  3819.          case 7: case 8: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4, 0); break;
  3820.         }
  3821.         
  3822.         dataptr += MAX_WORDS_PER_LINE*2;
  3823.         xpos2 = xpos + 32 + bpldelay2*2;
  3824.         switch (bplplanecnt) {
  3825.          case 2: case 3: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 1, 1); break;
  3826.          case 4: case 5: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 2, 1); break;
  3827.          case 6: case 7: doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 3, 1); break;
  3828.          case 8:         doop_planes_lores_unaligned_h ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 4, 1); break;
  3829.         }
  3830.     }
  3831.     }
  3832. }
  3833.  
  3834. static void pfield_doline_unaligned_l (int lineno)
  3835. {
  3836.     int xpos = dp_for_drawing->plfstrt * 2 - DISPLAY_LEFT_SHIFT;
  3837.         
  3838.     if (bplhires) {
  3839.     int xpos1 = xpos + 8 + bpldelay1;
  3840.     int xpos2;
  3841.     uae_u8 *dataptr = line_data[lineno];
  3842.  
  3843.     if (bpldelay1 == bpldelay2) {
  3844.         switch (bplplanecnt) {
  3845.          case 1: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1); break;
  3846.          case 2: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2); break;
  3847.          case 3: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3); break;
  3848.          case 4: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4); break;
  3849.          case 5: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 5); break;
  3850.          case 6: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 6); break;
  3851.          case 7: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 7); break;
  3852.          case 8: set_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 8); break;
  3853.         }
  3854.     } else {
  3855.         switch (bplplanecnt) {
  3856.          case 1: case 2: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1, 0); break;
  3857.          case 3: case 4: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2, 0); break;
  3858.          case 5: case 6: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3, 0); break;
  3859.          case 7: case 8: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4, 0); break;
  3860.         }
  3861.  
  3862.         dataptr += MAX_WORDS_PER_LINE*2;
  3863.         xpos2 = xpos + 8 + bpldelay2;
  3864.         switch (bplplanecnt) {
  3865.          case 2: case 3: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 1, 1); break;
  3866.          case 4: case 5: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 2, 1); break;
  3867.          case 6: case 7: doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 3, 1); break;
  3868.          case 8:         doop_planes_hires_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 4, 1); break;
  3869.         }
  3870.     }
  3871.     } else {
  3872.     int xpos1 = xpos + 16 + bpldelay1;
  3873.     int xpos2;
  3874.     uae_u8 *dataptr = line_data[lineno];
  3875.  
  3876.     if (bpldelay1 == bpldelay2) {
  3877.         switch (bplplanecnt) {
  3878.          case 1: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1); break;
  3879.          case 2: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2); break;
  3880.          case 3: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3); break;
  3881.          case 4: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4); break;
  3882.          case 5: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 5); break;
  3883.          case 6: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 6); break;
  3884.          case 7: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 7); break;
  3885.          case 8: set_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 8); break;
  3886.         }
  3887.     } else {
  3888.         switch (bplplanecnt) {
  3889.          case 1: case 2: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 1, 0); break;
  3890.          case 3: case 4: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 2, 0); break;
  3891.          case 5: case 6: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 3, 0); break;
  3892.          case 7: case 8: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos1), dataptr, 4, 0); break;
  3893.         }
  3894.         
  3895.         dataptr += MAX_WORDS_PER_LINE*2;
  3896.         xpos2 = xpos + 16 + bpldelay2;
  3897.         switch (bplplanecnt) {
  3898.          case 2: case 3: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 1, 1); break;
  3899.          case 4: case 5: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 2, 1); break;
  3900.          case 6: case 7: doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 3, 1); break;
  3901.          case 8:         doop_planes_lores_unaligned_l ((uae_u32 *)(pixdata.apixels + xpos2), dataptr, 4, 1); break;
  3902.         }
  3903.     }
  3904.     }
  3905. }
  3906.  
  3907. #define pfield_doline_h pfield_doline_unaligned_h
  3908. #define pfield_doline_l pfield_doline_unaligned_l
  3909.  
  3910. #else /* not UNALIGNED_PROFITABLE */
  3911.  
  3912.  
  3913. static __inline__ void pfield_orword_hires_h(int data, unsigned char *dp, int bit)
  3914. {
  3915.     uae_u32 *pixptr = (uae_u32 *)dp;
  3916.  
  3917.     *pixptr |= hirestab_h[data >> 8][0] << bit;
  3918.     *(pixptr+1) |= hirestab_h[data >> 8][1] << bit;
  3919.     *(pixptr+2) |= hirestab_h[data & 255][0] << bit;
  3920.     *(pixptr+3) |= hirestab_h[data & 255][1] << bit;
  3921. }
  3922.  
  3923. static __inline__ void pfield_orword_lores_h(int data, unsigned char *dp, int bit)
  3924. {
  3925.     uae_u32 *pixptr = (uae_u32 *)dp;
  3926.     
  3927.     *pixptr |= lorestab_h[data >> 8][0] << bit;
  3928.     *(pixptr+1) |= lorestab_h[data >> 8][1] << bit;
  3929.     *(pixptr+2) |= lorestab_h[data >> 8][2] << bit;
  3930.     *(pixptr+3) |= lorestab_h[data >> 8][3] << bit;
  3931.     *(pixptr+4) |= lorestab_h[data & 255][0] << bit;
  3932.     *(pixptr+5) |= lorestab_h[data & 255][1] << bit;
  3933.     *(pixptr+6) |= lorestab_h[data & 255][2] << bit;
  3934.     *(pixptr+7) |= lorestab_h[data & 255][3] << bit;
  3935. }
  3936.  
  3937. static __inline__ void pfield_setword_hires_h(int data, unsigned char *dp, int bit)
  3938. {
  3939.     uae_u32 *pixptr = (uae_u32 *)dp;
  3940.  
  3941.     *pixptr = hirestab_h[data >> 8][0] << bit;
  3942.     *(pixptr+1) = hirestab_h[data >> 8][1] << bit;
  3943.     *(pixptr+2) = hirestab_h[data & 255][0] << bit;
  3944.     *(pixptr+3) = hirestab_h[data & 255][1] << bit;
  3945. }
  3946.  
  3947. static __inline__ void pfield_setword_lores_h(int data, unsigned char *dp, int bit)
  3948. {
  3949.     uae_u32 *pixptr = (uae_u32 *)dp;
  3950.     
  3951.     *pixptr = lorestab_h[data >> 8][0] << bit;
  3952.     *(pixptr+1) = lorestab_h[data >> 8][1] << bit;
  3953.     *(pixptr+2) = lorestab_h[data >> 8][2] << bit;
  3954.     *(pixptr+3) = lorestab_h[data >> 8][3] << bit;
  3955.     *(pixptr+4) = lorestab_h[data & 255][0] << bit;
  3956.     *(pixptr+5) = lorestab_h[data & 255][1] << bit;
  3957.     *(pixptr+6) = lorestab_h[data & 255][2] << bit;
  3958.     *(pixptr+7) = lorestab_h[data & 255][3] << bit;
  3959. }
  3960.  
  3961. static __inline__ void pfield_orword_hires_l(int data, unsigned char *dp, int bit)
  3962. {
  3963.     uae_u32 *pixptr = (uae_u32 *)dp;
  3964.  
  3965.     *pixptr |= hirestab_l[data >> 8][0] << bit;
  3966.     *(pixptr+1) |= hirestab_l[data & 255][0] << bit;
  3967. }
  3968.  
  3969. static __inline__ void pfield_orword_lores_l(int data, unsigned char *dp, int bit)
  3970. {
  3971.     uae_u32 *pixptr = (uae_u32 *)dp;
  3972.     
  3973.     *pixptr |= lorestab_l[data >> 8][0] << bit;
  3974.     *(pixptr+1) |= lorestab_l[data >> 8][1] << bit;
  3975.     *(pixptr+2) |= lorestab_l[data & 255][0] << bit;
  3976.     *(pixptr+3) |= lorestab_l[data & 255][1] << bit;
  3977. }
  3978.  
  3979. static __inline__ void pfield_setword_hires_l(int data, unsigned char *dp, int bit)
  3980. {
  3981.     uae_u32 *pixptr = (uae_u32 *)dp;
  3982.  
  3983.     *pixptr = hirestab_l[data >> 8][0] << bit;
  3984.     *(pixptr+1) = hirestab_l[data & 255][0] << bit;
  3985. }
  3986.  
  3987. static __inline__ void pfield_setword_lores_l(int data, unsigned char *dp, int bit)
  3988. {
  3989.     uae_u32 *pixptr = (uae_u32 *)dp;
  3990.     
  3991.     *pixptr = lorestab_l[data >> 8][0] << bit;
  3992.     *(pixptr+1) = lorestab_l[data >> 8][1] << bit;
  3993.     *(pixptr+2) = lorestab_l[data & 255][0] << bit;
  3994.     *(pixptr+3) = lorestab_l[data & 255][1] << bit;
  3995. }
  3996.  
  3997. #define DO_ONE_PLANE(POINTER, MULT, FUNC, DELAY, LL_SUB, P_ADD) { \
  3998.     int i; \
  3999.     unsigned int bpldat1; \
  4000.     uae_u16 data; \
  4001.     unsigned int bpldat2 = 0; \
  4002.     uae_u8 *ptr = (POINTER); \
  4003.     for (i = dp_for_drawing->plflinelen; i > 0; i -= LL_SUB) { \
  4004.         bpldat1 = bpldat2; \
  4005.     bpldat2 = do_get_mem_word ((uae_u16 *)ptr); \
  4006.         ptr+=2; \
  4007.     data = (bpldat1 << (16 - DELAY)) | (bpldat2 >> DELAY); \
  4008.     FUNC(data, app, MULT); \
  4009.     app += P_ADD; \
  4010.     } \
  4011.     data = bpldat2 << (16 - DELAY); \
  4012.     FUNC(data, app, MULT); \
  4013. }
  4014.  
  4015. #ifdef SMART_UPDATE
  4016. #define DATA_POINTER(n) (dataptr + (n)*MAX_WORDS_PER_LINE*2)
  4017. #else
  4018. #define DATA_POINTER(n) (real_bplpt[n])
  4019. #endif
  4020.  
  4021. static void pfield_doline_aligned_h (int lineno)
  4022. {
  4023.     int xpos = dp_for_drawing->plfstrt * 4 - DISPLAY_LEFT_SHIFT * 2;
  4024.     
  4025.     if (bplhires) {
  4026.     if (bplplanecnt > 0) {
  4027.         int xpos1 = xpos + 16 + (bpldelay1 >= 8 ? 16 : 0);
  4028.         int xpos2 = xpos + 16 + (bpldelay2 >= 8 ? 16 : 0);
  4029.         int delay1 = 2*(bpldelay1 & 7);
  4030.         int delay2 = 2*(bpldelay2 & 7);
  4031.         unsigned char *app = pixdata.apixels + xpos1;
  4032.         uae_u8 *dataptr = line_data[lineno];
  4033.  
  4034.         DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_hires_h, delay1, 4, 16);
  4035.         if (bplplanecnt > 2) {
  4036.         app = pixdata.apixels + xpos1;
  4037.         DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_hires_h, delay1, 4, 16);
  4038.         }
  4039. #if AGA_CHIPSET == 1
  4040.         if (bplplanecnt > 4) {
  4041.         app = pixdata.apixels + xpos1;
  4042.         DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_hires_h, delay1, 4, 16);
  4043.         }
  4044.         if (bplplanecnt > 6) {
  4045.         app = pixdata.apixels + xpos1;
  4046.         DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_hires_h, delay1, 4, 16);
  4047.         }
  4048. #endif
  4049.         if (bplplanecnt > 1) {
  4050.         app = pixdata.apixels + xpos2;
  4051.         DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_hires_h, delay2, 4, 16);
  4052.         }
  4053.         if (bplplanecnt > 3) {
  4054.         app = pixdata.apixels + xpos2;
  4055.         DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_hires_h, delay2, 4, 16);
  4056.         }
  4057. #if AGA_CHIPSET == 1
  4058.         if (bplplanecnt > 5) {
  4059.         app = pixdata.apixels + xpos2;
  4060.         DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_hires_h, delay2, 4, 16);
  4061.         }
  4062.         if (bplplanecnt > 7) {
  4063.         app = pixdata.apixels + xpos2;
  4064.         DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_hires_h, delay2, 4, 16);
  4065.         }
  4066. #endif
  4067.     } else {
  4068.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  4069.     }
  4070.     } else {
  4071.     if (bplplanecnt > 0) {
  4072.         int x = xpos + 32;
  4073.         unsigned char *app = pixdata.apixels + x;
  4074.         uae_u8 *dataptr = line_data[lineno];
  4075.         
  4076.         DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_lores_h, bpldelay1, 8, 32);
  4077.         if (bplplanecnt > 2) {
  4078.         app = pixdata.apixels + x;
  4079.         DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_lores_h, bpldelay1, 8, 32);
  4080.         }
  4081.         if (bplplanecnt > 4) {
  4082.         app = pixdata.apixels + x;
  4083.         DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_lores_h, bpldelay1, 8, 32);
  4084.         }
  4085. #if AGA_CHIPSET == 1
  4086.         if (bplplanecnt > 6) {
  4087.         app = pixdata.apixels + x;
  4088.         DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_lores_h, bpldelay1, 8, 32);
  4089.         }
  4090. #endif
  4091.         if (bplplanecnt > 1) {
  4092.         app = pixdata.apixels + x;
  4093.         DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_lores_h, bpldelay2, 8, 32);
  4094.         }
  4095.         if (bplplanecnt > 3) {
  4096.         app = pixdata.apixels + x;
  4097.         DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_lores_h, bpldelay2, 8, 32);
  4098.         }
  4099.         if (bplplanecnt > 5) {
  4100.         app = pixdata.apixels + x;
  4101.         DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_lores_h, bpldelay2, 8, 32);
  4102.         }
  4103. #if AGA_CHIPSET == 1
  4104.         if (bplplanecnt > 7) {
  4105.         app = pixdata.apixels + x;
  4106.         DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_lores_h, bpldelay2, 8, 32);
  4107.         }
  4108. #endif
  4109.     } else {
  4110.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  4111.     }
  4112.     }
  4113. }
  4114.  
  4115. static void pfield_doline_aligned_l (int lineno)
  4116. {
  4117.     int xpos = dp_for_drawing->plfstrt * 2 - DISPLAY_LEFT_SHIFT;
  4118.         
  4119.     if (bplhires) {
  4120.     if (bplplanecnt > 0) {
  4121.         int xpos1 = xpos + 8 + (bpldelay1 >= 8 ? 8 : 0);
  4122.         int xpos2 = xpos + 8 + (bpldelay2 >= 8 ? 8 : 0);
  4123.         int delay1 = (bpldelay1 & 7) * 2;
  4124.         int delay2 = (bpldelay2 & 7) * 2;
  4125.         unsigned char *app = pixdata.apixels + xpos1;
  4126.         uae_u8 *dataptr = line_data[lineno];
  4127.         
  4128.         DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_hires_l, delay1, 4, 8);
  4129.         if (bplplanecnt > 2) {
  4130.         app = pixdata.apixels + xpos1;
  4131.         DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_hires_l, delay1, 4, 8);
  4132.         }
  4133. #if AGA_CHIPSET == 1
  4134.         if (bplplanecnt > 4) {
  4135.         app = pixdata.apixels + xpos1;
  4136.         DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_hires_l, delay1, 4, 8);
  4137.         }
  4138.         if (bplplanecnt > 6) {
  4139.         app = pixdata.apixels + xpos1;
  4140.         DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_hires_l, delay1, 4, 8);
  4141.         }
  4142. #endif
  4143.         if (bplplanecnt > 1) {
  4144.         app = pixdata.apixels + xpos2;
  4145.         DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_hires_l, delay2, 4, 8);
  4146.         }
  4147.         if (bplplanecnt > 3) {
  4148.         app = pixdata.apixels + xpos2;
  4149.         DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_hires_l, delay2, 4, 8);
  4150.         }
  4151. #if AGA_CHIPSET == 1
  4152.         if (bplplanecnt > 5) {
  4153.         app = pixdata.apixels + xpos2;
  4154.         DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_hires_l, delay2, 4, 8);
  4155.         }
  4156.         if (bplplanecnt > 7) {
  4157.         app = pixdata.apixels + xpos2;
  4158.         DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_hires_l, delay2, 4, 8);
  4159.         }
  4160. #endif
  4161.     } else {
  4162.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  4163.     }
  4164.     } else {
  4165.     if (bplplanecnt > 0) {
  4166.         int x = xpos + 16;
  4167.         int delay1 = bpldelay1;
  4168.         int delay2 = bpldelay2;
  4169.         unsigned char *app = pixdata.apixels + x;
  4170.         uae_u8 *dataptr = line_data[lineno];
  4171.         
  4172.         DO_ONE_PLANE(DATA_POINTER(0), 0, pfield_setword_lores_l, delay1, 8, 16);
  4173.         if (bplplanecnt > 2) {
  4174.         app = pixdata.apixels + x;
  4175.         DO_ONE_PLANE(DATA_POINTER(2), 2, pfield_orword_lores_l, delay1, 8, 16);
  4176.         }
  4177.         if (bplplanecnt > 4) {
  4178.         app = pixdata.apixels + x;
  4179.         DO_ONE_PLANE(DATA_POINTER(4), 4, pfield_orword_lores_l, delay1, 8, 16);
  4180.         }
  4181. #if AGA_CHIPSET == 1
  4182.         if (bplplanecnt > 6) {
  4183.         app = pixdata.apixels + x;
  4184.         DO_ONE_PLANE(DATA_POINTER(6), 6, pfield_orword_lores_l, delay1, 8, 16);
  4185.         }
  4186. #endif
  4187.         if (bplplanecnt > 1) {
  4188.         app = pixdata.apixels + x;
  4189.         DO_ONE_PLANE(DATA_POINTER(1), 1, pfield_orword_lores_l, delay2, 8, 16);
  4190.         }
  4191.         if (bplplanecnt > 3) {
  4192.         app = pixdata.apixels + x;
  4193.         DO_ONE_PLANE(DATA_POINTER(3), 3, pfield_orword_lores_l, delay2, 8, 16);
  4194.         }
  4195.         if (bplplanecnt > 5) {
  4196.         app = pixdata.apixels + x;
  4197.         DO_ONE_PLANE(DATA_POINTER(5), 5, pfield_orword_lores_l, delay2, 8, 16);
  4198.         }
  4199. #if AGA_CHIPSET == 1
  4200.         if (bplplanecnt > 7) {
  4201.         app = pixdata.apixels + x;
  4202.         DO_ONE_PLANE(DATA_POINTER(7), 7, pfield_orword_lores_l, delay2, 8, 16);
  4203.         }
  4204. #endif
  4205.     } else {
  4206.         memset(pixdata.apixels, 0, sizeof(pixdata.apixels));
  4207.     }
  4208.     }
  4209. }
  4210.  
  4211. #define pfield_doline_h pfield_doline_aligned_h
  4212. #define pfield_doline_l pfield_doline_aligned_l
  4213.  
  4214. #endif /* UNALIGNED_PROFITABLE */
  4215.  
  4216. static void pfield_adjust_delay (void)
  4217. {
  4218.     int ddf_left = dp_for_drawing->plfstrt;
  4219.     int ddf_right = dp_for_drawing->plfstrt + dp_for_drawing->plflinelen;
  4220.     int i;
  4221.     
  4222.     for (i = dip_for_drawing->last_delay_change-1; i >= dip_for_drawing->first_delay_change-1; i--) {
  4223.     int delayreg = i < dip_for_drawing->first_delay_change ? dp_for_drawing->bplcon1 : delay_changes[i].value;
  4224.     int delay1 = delayreg & 0xF;
  4225.     int delay2 = (delayreg >> 4) & 0xF;
  4226.     int startpos = i == dip_for_drawing->last_delay_change - 1 ? ddf_right + 8 : delay_changes[i+1].linepos;
  4227.     int stoppos = i < dip_for_drawing->first_delay_change ? ddf_left : delay_changes[i].linepos;
  4228.     int j;
  4229.     startpos = PIXEL_XPOS (startpos + (bplhires ? 4 : 8));
  4230.     stoppos = PIXEL_XPOS (stoppos + (bplhires ? 4 : 8));
  4231.     if (currprefs.gfx_lores == 0)
  4232.         delay1 <<= 1, delay2 <<= 1;
  4233.     else if (currprefs.gfx_lores == 2)
  4234.         startpos >>= 1, stoppos >>= 1;
  4235.     for (j = startpos-1; j >= stoppos; j--) {
  4236.         pixdata.apixels [j] = (pixdata.apixels[j-delay1] & 0x55) | (pixdata.apixels[j-delay2] & 0xAA);
  4237.     }
  4238.     }
  4239. }
  4240.  
  4241. static void init_hardware_frame (void)
  4242. {
  4243.     int i;
  4244.  
  4245.     for (i = 0; i < 8; i++) {
  4246.     sprst[i] = SPR_stop;
  4247.     spron[i] = 0;
  4248.     }
  4249. #if 0
  4250.     memset(sprpos, 0, sizeof sprpos);
  4251.     memset(sprctl, 0, sizeof sprctl);
  4252. #endif
  4253.  
  4254.     next_lineno = 0;
  4255.     nln_how = 0;
  4256.     diwstate = DIW_waiting_start;
  4257.     hdiwstate = DIW_waiting_start;
  4258. }
  4259.  
  4260. static void setdontcare(void)
  4261. {
  4262.     write_log ("Don't care mouse mode set\n");
  4263.     mousestate = dont_care_mouse;
  4264.     lastspr0x = lastmx; lastspr0y = lastmy;
  4265.     mstepx = defstepx; mstepy = defstepy;
  4266. }
  4267.  
  4268. static void setfollow(void)
  4269. {
  4270.     write_log ("Follow sprite mode set\n");
  4271.     mousestate = follow_mouse;
  4272.     lastdiffx = lastdiffy = 0;
  4273.     sprvbfl = 0;
  4274.     spr0ctl=spr0pos = 0;
  4275.     mstepx = defstepx; mstepy = defstepy;
  4276. }
  4277.  
  4278. uae_u32 mousehack_helper (void)
  4279. {
  4280.     int mousexpos, mouseypos;
  4281.  
  4282.     mousexpos = lastmx + linetoscr_x_adjust;
  4283.     if (lastmy >= gfxvidinfo.maxline)
  4284.     lastmy = gfxvidinfo.maxline-1;
  4285.     mouseypos = native2amiga_line_map[lastmy] + thisframe_y_adjust - minfirstline;
  4286.     mouseypos <<= 1;
  4287.     mousexpos <<= (1-lores_shift);
  4288.     mousexpos += 2*DISPLAY_LEFT_SHIFT;
  4289.  
  4290.     switch (m68k_dreg (regs, 0)) {
  4291.      case 0:
  4292.     return ievent_alive ? -1 : needmousehack ();
  4293.      case 1:
  4294.     ievent_alive = 10;
  4295.     return mousexpos;
  4296.      case 2:
  4297.     return mouseypos;
  4298.     }
  4299.     return 0;
  4300. }
  4301.  
  4302. void togglemouse(void)
  4303. {
  4304.     switch(mousestate) {
  4305.      case dont_care_mouse: setfollow(); break;
  4306.      case follow_mouse: setdontcare(); break;
  4307.      default: break; /* Nnnnnghh! */
  4308.     }
  4309. }        
  4310.  
  4311. static __inline__ int adjust(int val)
  4312. {
  4313.     if (val>127)
  4314.     return 127; 
  4315.     else if (val<-127)
  4316.     return -127;
  4317.     return val;
  4318. }
  4319.  
  4320. static void do_mouse_hack(void)
  4321. {
  4322.     int spr0x = ((spr0pos & 0xff) << 2) | ((spr0ctl & 1) << 1);
  4323.     int spr0y = ((spr0pos >> 8) | ((spr0ctl & 4) << 6)) << 1;
  4324.     int diffx, diffy;
  4325.     
  4326.     if (ievent_alive > 0) {
  4327.     mouse_x = mouse_y = 0;
  4328.     return;
  4329.     }
  4330.     switch (mousestate) {
  4331.      case normal_mouse:
  4332.     diffx = lastmx - lastsampledmx;
  4333.     diffy = lastmy - lastsampledmy;
  4334.     if (!newmousecounters) {    
  4335.         if (diffx > 127) diffx = 127;
  4336.         if (diffx < -127) diffx = -127;
  4337.         mouse_x += diffx;
  4338.         if (diffy > 127) diffy = 127;
  4339.         if (diffy < -127) diffy = -127;
  4340.         mouse_y += diffy;
  4341.     }
  4342.     lastsampledmx += diffx; lastsampledmy += diffy;
  4343.     break;
  4344.  
  4345.      case dont_care_mouse:
  4346.     diffx = adjust (((lastmx-lastspr0x) * mstepx) >> 16);
  4347.     diffy = adjust (((lastmy-lastspr0y) * mstepy) >> 16);
  4348.     lastspr0x=lastmx; lastspr0y=lastmy;
  4349.     mouse_x+=diffx; mouse_y+=diffy;
  4350.     break;
  4351.     
  4352.      case follow_mouse:
  4353.     if (sprvbfl && sprvbfl-- >1) {
  4354.         int mousexpos, mouseypos;
  4355.         
  4356.         if ((lastdiffx > docal || lastdiffx < -docal) && lastspr0x != spr0x 
  4357.         && spr0x > plfstrt*4 + 34 + xcaloff && spr0x < plfstop*4 - xcaloff)
  4358.         {  
  4359.         int val = (lastdiffx << 16) / (spr0x - lastspr0x);
  4360.         if (val>=0x8000) mstepx=(mstepx*(calweight-1)+val)/calweight;
  4361.         }
  4362.         if ((lastdiffy > docal || lastdiffy < -docal) && lastspr0y != spr0y
  4363.         && spr0y>plffirstline+ycaloff && spr0y<plflastline-ycaloff) 
  4364.         { 
  4365.         int val = (lastdiffy<<16) / (spr0y-lastspr0y);
  4366.         if (val>=0x8000) mstepy=(mstepy*(calweight-1)+val)/calweight;
  4367.         }
  4368.         mousexpos = lastmx + linetoscr_x_adjust;
  4369.         if (lastmy >= gfxvidinfo.maxline)
  4370.         lastmy = gfxvidinfo.maxline-1;
  4371.         mouseypos = native2amiga_line_map[lastmy] + thisframe_y_adjust - minfirstline;
  4372.         mouseypos <<= 1;
  4373.         mousexpos <<= (1-lores_shift);
  4374.         mousexpos += 2*DISPLAY_LEFT_SHIFT;
  4375.         diffx = adjust ((((mousexpos + xoffs - spr0x) & ~1) * mstepx) >> 16);
  4376.         diffy = adjust ((((mouseypos + yoffs - spr0y) & ~1) * mstepy) >> 16);
  4377.         lastspr0x=spr0x; lastspr0y=spr0y;
  4378.         lastdiffx=diffx; lastdiffy=diffy;
  4379.         mouse_x+=diffx; mouse_y+=diffy; 
  4380.     }
  4381.     break;
  4382.     }
  4383. }
  4384.  
  4385. static void init_row_map(void)
  4386. {
  4387.     int i;
  4388.     for (i = 0; i < gfxvidinfo.maxline + 1; i++)
  4389.     row_map[i] = gfxvidinfo.bufmem + gfxvidinfo.rowbytes * i;
  4390. }
  4391.  
  4392. /* @@@ Are those still useful? */
  4393.  
  4394. /*
  4395.  * A raster line has been built in the graphics buffer. Tell the graphics code
  4396.  * to do anything necessary to display it.
  4397.  */
  4398. static __inline__ void do_flush_line_1 (int lineno)
  4399. {
  4400.     if (lineno < first_drawn_line)
  4401.     first_drawn_line = lineno;
  4402.     if (lineno > last_drawn_line)
  4403.     last_drawn_line = lineno;
  4404.  
  4405.     if (gfxvidinfo.maxblocklines == 0)
  4406.     flush_line(lineno);
  4407.     else {
  4408.     if ((last_block_line+1) != lineno) {
  4409.         if (first_block_line != -2)
  4410.         flush_block (first_block_line, last_block_line);
  4411.         first_block_line = lineno;
  4412.     }
  4413.     last_block_line = lineno;
  4414.     if (last_block_line - first_block_line >= gfxvidinfo.maxblocklines) {
  4415.         flush_block (first_block_line, last_block_line);
  4416.         first_block_line = last_block_line = -2;
  4417.     }
  4418.     }
  4419. }
  4420.  
  4421. static void do_flush_line (int lineno)
  4422. {
  4423.     /* We don't want to call X libraries from the second thread right now. */
  4424. #ifndef SUPPORT_PENGUINS
  4425.     do_flush_line_1 (lineno);
  4426. #else
  4427.     line_drawn[lineno] = 1;
  4428. #endif
  4429. }
  4430.  
  4431. /*
  4432.  * One Amiga frame has been finished. Tell the graphics code about it.
  4433.  * Note that the actual flush_screen() call is a no-op for all reasonable
  4434.  * systems.
  4435.  */
  4436.  
  4437. static void do_flush_screen (int start, int stop)
  4438. {
  4439.     int i;
  4440. #ifdef SUPPORT_PENGUINS
  4441.     for (i = 0; i < gfxvidinfo.maxline; i++) {
  4442.     if (line_drawn[i])
  4443.         do_flush_line_1 (i);
  4444.     }
  4445. #endif
  4446.     if (gfxvidinfo.maxblocklines != 0 && first_block_line != -2) {
  4447.     flush_block (first_block_line, last_block_line);
  4448.     }
  4449.     if (start <= stop)
  4450.     flush_screen (start, stop);
  4451. }
  4452.  
  4453. static void adjust_drawing_colors (int ctable, int bplham)
  4454. {
  4455.     if (drawing_color_matches != ctable) {
  4456.     if (bplham) {
  4457.         memcpy (&colors_for_drawing, curr_color_tables + ctable,
  4458.             sizeof colors_for_drawing);
  4459.         color_match_type = color_match_full;
  4460.     } else {
  4461.         memcpy (colors_for_drawing.acolors, curr_color_tables[ctable].acolors,
  4462.             sizeof colors_for_drawing.acolors);
  4463.         color_match_type = color_match_acolors;
  4464.     }
  4465.     drawing_color_matches = ctable;
  4466.     } else if (bplham && color_match_type != color_match_full) {
  4467.     memcpy (colors_for_drawing.color_regs, curr_color_tables[ctable].color_regs,
  4468.         sizeof colors_for_drawing.color_regs);
  4469.     color_match_type = color_match_full;
  4470.     }
  4471. }
  4472.  
  4473. static __inline__ void adjust_color0_for_color_change (void)
  4474. {
  4475.     drawing_color_matches = -1;
  4476.     if (dp_for_drawing->color0 != 0xFFFFFFFFul) {
  4477.     colors_for_drawing.color_regs[0] = dp_for_drawing->color0;
  4478.     colors_for_drawing.acolors[0] = xcolors[dp_for_drawing->color0];
  4479.     }
  4480. }
  4481.  
  4482. static __inline__ void do_color_changes (line_draw_func worker)
  4483. {
  4484.     int lastpos = 0, nextpos, i;
  4485.     struct color_change *cc = curr_color_changes + dip_for_drawing->first_color_change;
  4486.     
  4487.     for (i = dip_for_drawing->first_color_change; i <= dip_for_drawing->last_color_change; i++, cc++) {
  4488.     if (i == dip_for_drawing->last_color_change)
  4489.         nextpos = max_diwlastword;
  4490.     else
  4491.         nextpos = PIXEL_XPOS (cc->linepos) + (COPPER_MAGIC_FUDGE << lores_shift);
  4492.     worker (lastpos, nextpos);
  4493.     if (i != dip_for_drawing->last_color_change) {
  4494.         colors_for_drawing.color_regs[cc->regno] = cc->value;
  4495.         colors_for_drawing.acolors[cc->regno] = xcolors[cc->value];
  4496.     }
  4497.     if (nextpos > lastpos) {
  4498.         lastpos = nextpos;
  4499.         if (lastpos >= linetoscr_right_x)
  4500.         break;
  4501.     }
  4502.     }
  4503. }
  4504.  
  4505. static void pfield_expand_dp_bplcon (void)
  4506. {
  4507.     bplhires = (dp_for_drawing->bplcon0 & 0x8000) == 0x8000;
  4508.     bplplanecnt = (dp_for_drawing->bplcon0 & 0x7000) >> 12;
  4509.     bplham = (dp_for_drawing->bplcon0 & 0x800) == 0x800;
  4510. #if AGA_CHIPSET == 1 /* The KILLEHB bit exists in ECS, but is apparently meant for Genlock
  4511.                   * stuff, and it's set by some demos (e.g. Andromeda Seven Seas) */
  4512.     bplehb = ((dp_for_drawing->bplcon0 & 0xFCC0) == 0x6000 && !(dp_for_drawing->bplcon2 & 0x200));
  4513. #else
  4514.     bplehb = (dp_for_drawing->bplcon0 & 0xFC00) == 0x6000;
  4515. #endif
  4516.     bpldelay1 = dp_for_drawing->bplcon1 & 0xF; 
  4517.     bpldelay2 = (dp_for_drawing->bplcon1 >> 4) & 0xF; 
  4518.     plfpri[1] = 1 << 2*(dp_for_drawing->bplcon2 & 7);
  4519.     plfpri[2] = 1 << 2*((dp_for_drawing->bplcon2 >> 3) & 7);
  4520.     bpldualpf = (dp_for_drawing->bplcon0 & 0x400) == 0x400;
  4521.     bpldualpfpri = (dp_for_drawing->bplcon2 & 0x40) == 0x40;
  4522. }
  4523.  
  4524. static __inline__ void pfield_draw_line(int lineno, int gfx_ypos, int follow_ypos)
  4525. {
  4526.     int border = 0;
  4527.     int to_screen = 0;
  4528.     int do_double = 0;
  4529.     
  4530.     dp_for_drawing = 0;
  4531.     dip_for_drawing = 0;
  4532.     switch (linestate[lineno]) {
  4533.      case LINE_AS_PREVIOUS:
  4534.      case LINE_REMEMBERED_AS_PREVIOUS:
  4535.     {
  4536.         static int warned = 0;
  4537.         if (!warned)
  4538.         write_log ("Shouldn't get here... this is a bug.\n"), warned++;
  4539.     }
  4540.     line_decisions[lineno].which = -2;
  4541.     return;
  4542.  
  4543.      case LINE_BORDER_PREV:
  4544.     border = 1;
  4545.     dp_for_drawing = line_decisions + lineno - 1;
  4546.     dip_for_drawing = curr_drawinfo + lineno - 1;
  4547.     break;
  4548.  
  4549.      case LINE_BORDER_NEXT:
  4550.     border = 1;
  4551.     dp_for_drawing = line_decisions + lineno + 1;
  4552.     dip_for_drawing = curr_drawinfo + lineno + 1;
  4553.     break;
  4554.  
  4555.      case LINE_DONE_AS_PREVIOUS:
  4556.     line_decisions[lineno].which = -2;
  4557.     /* fall through */
  4558.      case LINE_DONE:
  4559.     return;
  4560.  
  4561.      case LINE_DECIDED_DOUBLE:
  4562.     line_decisions[lineno+1].which = -2;
  4563.     if (follow_ypos != -1) {
  4564.         do_double = 1;
  4565.         linetoscr_double_offset = gfxvidinfo.rowbytes * (follow_ypos - gfx_ypos);
  4566.     }
  4567.     
  4568.     /* fall through */
  4569.      default:
  4570.     dip_for_drawing = curr_drawinfo + lineno;
  4571.     dp_for_drawing = line_decisions + lineno;
  4572.     if (dp_for_drawing->which != 1)
  4573.         border = 1;
  4574.     break;
  4575.     }
  4576.     
  4577.     if (!line_changed[lineno] && !frame_redraw_necessary) {
  4578.     /* The case where we can skip redrawing this line. If this line 
  4579.      * is supposed to be doubled, and the next line is remembered as
  4580.      * having been doubled, then the next line is done as well. */
  4581.     if (do_double) {
  4582.         if (linestate[lineno+1] != LINE_REMEMBERED_AS_PREVIOUS) {
  4583.         if (gfxvidinfo.linemem == NULL)
  4584.             memcpy (row_map[follow_ypos], row_map[gfx_ypos], gfxvidinfo.rowbytes);
  4585.         line_decisions[lineno + 1].which = -2;
  4586.         do_flush_line (follow_ypos);
  4587.         }
  4588.         linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
  4589.     }
  4590.     linestate[lineno] = LINE_DONE;
  4591.     return;
  4592.     }
  4593.  
  4594.     if (!border) {
  4595.     xlinebuffer = gfxvidinfo.linemem;
  4596.     if (xlinebuffer == NULL)
  4597.         xlinebuffer = row_map[gfx_ypos];
  4598.     xlinebuffer -= linetoscr_x_adjust_bytes;
  4599.     aga_lbufptr = aga_linebuf;
  4600.     
  4601.     pfield_expand_dp_bplcon ();
  4602.  
  4603. #ifdef LORES_HACK
  4604.     if (gfxvidinfo.can_double && !bplhires && !currprefs.gfx_lores
  4605.         && dip_for_drawing->nr_color_changes == 0 && !bplham)
  4606.         currprefs.gfx_lores = 2;
  4607. #endif
  4608.     pfield_init_linetoscr ();
  4609.     if (dip_for_drawing->first_delay_change != dip_for_drawing->last_delay_change) {
  4610.         bpldelay1 = bpldelay2 = 0;
  4611.         if (currprefs.gfx_lores)
  4612.         pfield_doline_l (lineno);
  4613.         else
  4614.         pfield_doline_h (lineno);
  4615.         pfield_adjust_delay ();
  4616.     } else {
  4617.         if (currprefs.gfx_lores)
  4618.         pfield_doline_l (lineno);
  4619.         else
  4620.         pfield_doline_h (lineno);
  4621.     }
  4622.  
  4623.     /* Check color0 adjust only if we have color changes - shouldn't happen
  4624.      * otherwise. */
  4625.     adjust_drawing_colors (dp_for_drawing->ctable, bplham || bplehb);
  4626.  
  4627.     /* The problem is that we must call decode_ham6() BEFORE we do the
  4628.      * sprites. */
  4629.     if (bplham) {
  4630.         init_ham_decoding(linetoscr_x_adjust);
  4631.         if (dip_for_drawing->nr_color_changes == 0) {
  4632.         /* The easy case: need to do HAM decoding only once for the
  4633.          * full line. */
  4634.         decode_ham6 (linetoscr_x_adjust, linetoscr_right_x);
  4635.         } else /* Argh. */ {        
  4636.         adjust_color0_for_color_change ();
  4637.         do_color_changes (decode_ham6);
  4638.         adjust_drawing_colors (dp_for_drawing->ctable, bplham || bplehb);
  4639.         }
  4640.     }
  4641.  
  4642.     if (dip_for_drawing->nr_sprites != 0) {
  4643.         int spr;
  4644.         walk_sprites (curr_sprite_positions + dip_for_drawing->first_sprite_draw, dip_for_drawing->nr_sprites);
  4645.     }
  4646.     if (dip_for_drawing->nr_color_changes == 0) {
  4647.         pfield_do_linetoscr_full (gfxvidinfo.linemem == NULL ? do_double : 0);
  4648.         do_flush_line (gfx_ypos);
  4649.         linestate[lineno] = LINE_DONE;
  4650.  
  4651.         if (do_double) {
  4652.         linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
  4653.         do_flush_line (follow_ypos);
  4654.         }
  4655.     } else {
  4656.         int lastpos = 0, nextpos, i;
  4657.  
  4658.         adjust_color0_for_color_change ();
  4659.         do_color_changes (pfield_do_linetoscr);
  4660.  
  4661.         linestate[lineno] = LINE_DONE;
  4662.         do_flush_line (gfx_ypos);
  4663.         if (do_double) {
  4664.         if (gfxvidinfo.linemem == NULL)
  4665.             memcpy (row_map[follow_ypos], row_map[gfx_ypos], gfxvidinfo.rowbytes);
  4666.         linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
  4667.         line_decisions[lineno + 1].which = -2;
  4668.         do_flush_line (follow_ypos);
  4669.         }
  4670.     }
  4671. #ifdef LORES_HACK
  4672.     if (currprefs.gfx_lores == 2)
  4673.         currprefs.gfx_lores = 0;
  4674. #endif
  4675.     } else {
  4676.     /* Border. */
  4677.     int i, lastpos = 0, nextpos;
  4678.     struct color_change *cc;
  4679.  
  4680.     xlinebuffer = gfxvidinfo.linemem;
  4681.     if (xlinebuffer == NULL)
  4682.         xlinebuffer = row_map[gfx_ypos];
  4683.     xlinebuffer -= linetoscr_x_adjust_bytes;
  4684.  
  4685.     adjust_drawing_colors (dp_for_drawing->ctable, 0);
  4686.     /* Check color0 adjust only if we have color changes - shouldn't happen
  4687.      * otherwise. */
  4688.  
  4689.     if (dip_for_drawing->nr_color_changes == 0) {
  4690.         fill_line ();
  4691.         do_flush_line (gfx_ypos);
  4692.         linestate[lineno] = LINE_DONE;
  4693.         if (do_double) {
  4694.         if (gfxvidinfo.linemem == NULL) {
  4695.             xlinebuffer = row_map[follow_ypos] - linetoscr_x_adjust_bytes;
  4696.             fill_line ();
  4697.         }
  4698.         do_flush_line (follow_ypos);
  4699.         linestate[lineno+1] = LINE_DONE_AS_PREVIOUS;
  4700.         }
  4701.         return;
  4702.     }
  4703.  
  4704.     adjust_color0_for_color_change ();
  4705.     do_color_changes (pfield_do_fill_line);
  4706.  
  4707.     do_flush_line (gfx_ypos);
  4708.     linestate[lineno] = LINE_DONE;
  4709.     if (do_double) {
  4710.         if (gfxvidinfo.linemem == NULL)
  4711.         memcpy (row_map[follow_ypos], row_map[gfx_ypos], gfxvidinfo.rowbytes);
  4712.         linestate[lineno + 1] = LINE_DONE_AS_PREVIOUS;
  4713.         line_decisions[lineno + 1].which = -2;
  4714.         do_flush_line (follow_ypos);
  4715.     }
  4716.     }
  4717. }
  4718.  
  4719. #ifdef SUPPORT_PENGUINS
  4720. static smp_comm_pipe drawing_pipe;
  4721. static uae_sem_t drawing_lock;
  4722.  
  4723. static void *drawing_penguin (void *cruxmedo)
  4724. {
  4725.     int l;
  4726.     fprintf(stderr, "Hello, world!\n");
  4727.  
  4728.     for (;;) {
  4729.     /* Start of a frame. */
  4730.     int k;
  4731.     new_frame:
  4732.     k = read_comm_pipe_int_blocking (&drawing_pipe);
  4733.  
  4734.     switch (k) {
  4735.      case -2:
  4736.         /* Hoopy */
  4737.         break;
  4738.         
  4739.      default:
  4740.         write_log ("Penguin got out of sync.\n");
  4741.         /* what can we do? Try to reduce the damage */
  4742.         for (;;) {
  4743.         k = read_comm_pipe_int_blocking (&drawing_pipe);
  4744.         if (k == -3)
  4745.             break;
  4746.         if (k == -1) {
  4747.             uae_sem_post (&drawing_lock);
  4748.             goto new_frame;
  4749.         }
  4750.         }
  4751.      case -3:
  4752.         UAE_PENGUIN_EXIT;
  4753.         /* Can't happen */
  4754.         return 0;
  4755.     }
  4756.  
  4757.     for (;;) {
  4758.         int i, where;
  4759.         int l = read_comm_pipe_int_blocking (&drawing_pipe);
  4760.         switch (l) {
  4761.          case -1:
  4762.         /* End-of-frame synchronization. */
  4763.         uae_sem_post (&drawing_lock);
  4764.         goto new_frame;
  4765.          case -2:
  4766.         /* customreset called a bit too often. That's harmless. */
  4767.         continue;
  4768.          case -3:
  4769.         write_log ("Penguin got out of sync.\n");
  4770.         UAE_PENGUIN_EXIT;
  4771.         return 0;
  4772.         }
  4773.  
  4774.         /* l is the line that has been finished for drawing. */
  4775.         i = l - thisframe_y_adjust_real;
  4776.         if (i < 0 || i >= max_ypos_thisframe)
  4777.         continue;
  4778.  
  4779.         if (linestate[l] == LINE_UNDECIDED) {
  4780.         fprintf (stderr, "Line scheduled for drawing, but undecided %d!?\n", l);
  4781.         continue;
  4782.         }
  4783.         if (inhibit_frame > 0)
  4784.         continue;
  4785.         where = amiga2aspect_line_map[i+min_ypos_for_screen];
  4786.         if (where >= gfxvidinfo.maxline || where == -1)
  4787.         continue;
  4788.  
  4789.         pfield_draw_line (l, where, amiga2aspect_line_map[i+min_ypos_for_screen+1]);
  4790.     }
  4791.     }
  4792. }
  4793.  
  4794. static penguin_id our_penguin;
  4795.  
  4796. static void kill_drawing_penguin (void)
  4797. {
  4798.     /* ??? does libpthread do that for us? */
  4799. }
  4800.  
  4801. #endif
  4802.  
  4803. static int penguins_enabled_thisframe;
  4804.  
  4805. static void init_drawing_frame (void)
  4806. {
  4807.     int i, maxline;
  4808.  
  4809. #ifdef OS_WITHOUT_MEMORY_MANAGEMENT
  4810.     if(delta_sprite_draw) {
  4811.         void *p1,*p2;
  4812.         int mcc = max_sprite_draw + 200 + delta_sprite_draw;
  4813.         delta_sprite_draw = 0;
  4814.         p1 = realloc(sprite_positions[0], mcc*sizeof(struct sprite_draw)); 
  4815.         p2 = realloc(sprite_positions[1], mcc*sizeof(struct sprite_draw)); 
  4816.         if(p1) sprite_positions[0] = p1;
  4817.         if(p2) sprite_positions[1] = p2;
  4818.         if(p1 && p2) {
  4819.             fprintf(stderr,"new max_sprite_draw=%d\n",mcc);
  4820.         max_sprite_draw = mcc;
  4821.     }
  4822.     }
  4823.     if(delta_color_change) {
  4824.         void *p1,*p2;
  4825.         int mcc = max_color_change + 200 + delta_color_change;
  4826.         delta_color_change = 0;
  4827.         p1 = realloc(color_changes[0], mcc*sizeof(struct color_change)); 
  4828.         p2 = realloc(color_changes[1], mcc*sizeof(struct color_change)); 
  4829.         if(p1) color_changes[0] = p1;
  4830.         if(p2) color_changes[1] = p2;
  4831.         if(p1 && p2) {
  4832.             fprintf(stderr,"new max_color_change=%d\n",mcc);
  4833.         max_color_change = mcc;
  4834.         }
  4835.     }
  4836.     if(delta_delay_change) {
  4837.         void *p;
  4838.         int mcc = max_delay_change + 200 + delta_delay_change;
  4839.         delta_delay_change = 0;
  4840.         p = realloc(delay_changes, mcc*sizeof(struct delay_change)); 
  4841.         if(p) {
  4842.             fprintf(stderr,"new max_delay_change=%d\n",mcc);
  4843.         delay_changes = p;
  4844.         max_delay_change = mcc;
  4845.         }
  4846.     }
  4847. #endif
  4848.  
  4849.     if (max_diwstop == 0)
  4850.     max_diwstop = diwlastword;
  4851.     if (min_diwstart > max_diwstop)
  4852.     min_diwstart = 0;
  4853.  
  4854.     if (thisframe_first_drawn_line == -1)
  4855.     thisframe_first_drawn_line = minfirstline;
  4856.     if (thisframe_first_drawn_line > thisframe_last_drawn_line)
  4857.     thisframe_last_drawn_line = thisframe_first_drawn_line;
  4858.  
  4859.     next_color_change = 0;
  4860.     next_delay_change = 0;
  4861.     next_sprite_draw = 0;
  4862.     maxline = currprefs.gfx_linedbl ? (maxvpos+1) * 2 + 1 : (maxvpos+1) + 1;
  4863. #ifdef SMART_UPDATE
  4864.     for (i = 0; i < maxline; i++)
  4865.     linestate[i] = linestate[i] == LINE_DONE_AS_PREVIOUS ? LINE_REMEMBERED_AS_PREVIOUS : LINE_UNDECIDED;
  4866. #else
  4867.     memset (linestate, LINE_UNDECIDED, maxline);
  4868. #endif
  4869.     last_drawn_line = 0;
  4870.     first_drawn_line = 32767;
  4871.  
  4872.     first_block_line = last_block_line = -2;
  4873.     if (currprefs.test_drawing_speed)
  4874.     frame_redraw_necessary = 1;
  4875.     else if (frame_redraw_necessary)
  4876.     frame_redraw_necessary--;
  4877.     
  4878.     next_color_entry = 0;
  4879.     remembered_color_entry = -1;
  4880.     prev_sprite_positions = sprite_positions[current_change_set];
  4881.     curr_sprite_positions = sprite_positions[current_change_set ^ 1];
  4882.     prev_color_changes = color_changes[current_change_set];
  4883.     curr_color_changes = color_changes[current_change_set ^ 1];
  4884.     prev_color_tables = color_tables[current_change_set];
  4885.     curr_color_tables = color_tables[current_change_set ^ 1];
  4886.     
  4887.     prev_drawinfo = line_drawinfo[current_change_set];
  4888.     curr_drawinfo = line_drawinfo[current_change_set ^= 1];
  4889.     drawing_color_matches = -1;
  4890.     color_src_match = color_dest_match = -1;
  4891.  
  4892.     prev_x_adjust = linetoscr_x_adjust;
  4893.     prev_y_adjust = thisframe_y_adjust;
  4894.  
  4895.     if (currprefs.gfx_xcenter) {
  4896.     if (max_diwstop - min_diwstart < gfxvidinfo.maxlinetoscr && currprefs.gfx_xcenter == 2)
  4897.         /* Try to center. */
  4898.         linetoscr_x_adjust = ((max_diwstop - min_diwstart - gfxvidinfo.maxlinetoscr) / 2 + min_diwstart) & ~1;
  4899.     else
  4900.         linetoscr_x_adjust = max_diwstop - gfxvidinfo.maxlinetoscr;
  4901.  
  4902.     /* Would the old value be good enough? If so, leave it as it is if we want to
  4903.      * be clever. */
  4904.     if (currprefs.gfx_xcenter == 2) {
  4905.         if (linetoscr_x_adjust < prev_x_adjust && prev_x_adjust < min_diwstart)
  4906.         linetoscr_x_adjust = prev_x_adjust;
  4907.     }
  4908.     } else
  4909.     linetoscr_x_adjust = max_diwlastword - gfxvidinfo.maxlinetoscr;
  4910.     if (linetoscr_x_adjust < 0)
  4911.     linetoscr_x_adjust = 0;
  4912.  
  4913.     linetoscr_x_adjust_bytes = linetoscr_x_adjust * gfxvidinfo.pixbytes;
  4914.  
  4915.     linetoscr_right_x = linetoscr_x_adjust + gfxvidinfo.maxlinetoscr;
  4916.     if (linetoscr_right_x > max_diwlastword)
  4917.     linetoscr_right_x = max_diwlastword;
  4918.  
  4919.     thisframe_y_adjust = minfirstline;
  4920.     if (currprefs.gfx_ycenter && thisframe_first_drawn_line != -1) {
  4921.     if (thisframe_last_drawn_line - thisframe_first_drawn_line < max_drawn_amiga_line && currprefs.gfx_ycenter == 2)
  4922.         thisframe_y_adjust = (thisframe_last_drawn_line - thisframe_first_drawn_line - max_drawn_amiga_line) / 2 + thisframe_first_drawn_line;
  4923.     else
  4924.         thisframe_y_adjust = thisframe_first_drawn_line;
  4925.     /* Would the old value be good enough? If so, leave it as it is if we want to
  4926.      * be clever. */
  4927.     if (currprefs.gfx_ycenter == 2) {
  4928.         if (thisframe_y_adjust != prev_y_adjust
  4929.         && prev_y_adjust <= thisframe_first_drawn_line
  4930.         && prev_y_adjust + max_drawn_amiga_line > thisframe_last_drawn_line)
  4931.         thisframe_y_adjust = prev_y_adjust;
  4932.     }
  4933.     /* Make sure the value makes sense */
  4934.     if (thisframe_y_adjust + max_drawn_amiga_line > maxvpos)
  4935.         thisframe_y_adjust = maxvpos - max_drawn_amiga_line;
  4936.     if (thisframe_y_adjust < minfirstline)
  4937.         thisframe_y_adjust = minfirstline;
  4938.     }
  4939.     thisframe_y_adjust_real = thisframe_y_adjust << (currprefs.gfx_linedbl ? 1 : 0);
  4940.     max_ypos_thisframe = (maxvpos - thisframe_y_adjust) << (currprefs.gfx_linedbl ? 1 : 0);
  4941.  
  4942.     if (prev_x_adjust != linetoscr_x_adjust || prev_y_adjust != thisframe_y_adjust)
  4943.     frame_redraw_necessary |= (bplcon0 & 4) && currprefs.gfx_linedbl ? 2 : 1;
  4944.  
  4945.     max_diwstop = 0;
  4946.     min_diwstart = 10000;
  4947.     thisframe_first_drawn_line = -1;
  4948.     thisframe_last_drawn_line = -1;
  4949. #ifdef SUPPORT_PENGUINS
  4950.     penguins_enabled_thisframe = 1;
  4951.     /* Tell the other thread that it can now expect data from us. */
  4952.     write_comm_pipe_int (&drawing_pipe, -2, 1);
  4953.     memset (line_drawn, 0, sizeof line_drawn);
  4954. #endif
  4955. }
  4956.  
  4957. static void finish_drawing_frame (void)
  4958. {
  4959.     int i;
  4960.  
  4961. #ifdef SUPPORT_PENGUINS
  4962.     /* Synchronize with other thread, then see whether there's something left for
  4963.      * us to draw. @@@ This is probably a big waste of cycles if the two threads
  4964.      * run at very different speeds - this one could draw stuff as well. */
  4965.     write_comm_pipe_int (&drawing_pipe, -1, 1);
  4966.     uae_sem_wait (&drawing_lock);
  4967. #else
  4968.  
  4969. #ifndef SMART_UPDATE
  4970.     /* @@@ This isn't exactly right yet. FIXME */
  4971.     if (!interlace_seen) {
  4972.     do_flush_screen (first_drawn_line, last_drawn_line);
  4973.     return;
  4974.     }
  4975. #endif
  4976.     for (i = 0; i < max_ypos_thisframe; i++) {
  4977.     int where;
  4978.     int line = i + thisframe_y_adjust_real;
  4979.  
  4980.     if (linestate[line] == LINE_UNDECIDED)
  4981.         break;
  4982.  
  4983.     where = amiga2aspect_line_map[i+min_ypos_for_screen];
  4984.     if (where >= gfxvidinfo.maxline)
  4985.         break;
  4986.     if (where == -1)
  4987.         continue;
  4988.  
  4989.     pfield_draw_line (line, where, amiga2aspect_line_map[i+min_ypos_for_screen+1]);
  4990.     }
  4991. #endif
  4992.     do_flush_screen (first_drawn_line, last_drawn_line);
  4993. }
  4994.  
  4995. static void vsync_handler (void)
  4996. {
  4997.     static int cnt = 0;
  4998.     uae_u16 dir;
  4999.     int button;
  5000.  
  5001. #ifdef FRAME_RATE_HACK /* put this here or at the end of the function? */
  5002.     {
  5003.     frame_time_t curr_time = read_processor_time();
  5004.     vsyncmintime += vsynctime;
  5005.     /* @@@ Mathias? How do you think we should do this? */
  5006.     /* If we are too far behind, or we just did a reset, adjust the
  5007.      * needed time. */
  5008.     if ((long int)(curr_time - vsyncmintime) > 0 || did_reset)
  5009.         vsyncmintime = curr_time + vsynctime;
  5010.     did_reset = 0;
  5011.     }
  5012. #endif
  5013.     handle_events ();
  5014.     if (cnt == 0) {
  5015.     DISK_check_change ();
  5016.     cnt = 5;
  5017.     }
  5018.     cnt--;
  5019.  
  5020.     getjoystate (0, &joy0dir, &joy0button);
  5021.     getjoystate (1, &joy1dir, &joy1button);
  5022.  
  5023.     do_mouse_hack();
  5024.     
  5025.     INTREQ(0x8020);
  5026.     if (bplcon0 & 4) 
  5027.     lof ^= 0x8000;
  5028.  
  5029.     if (quit_program < 0) {
  5030.     quit_program = -quit_program;
  5031.     inhibit_frame = 2;
  5032.     regs.spcflags |= SPCFLAG_BRK;
  5033.     if (framecnt == 0)
  5034.         finish_drawing_frame ();
  5035.     filesys_prepare_reset ();
  5036. #ifdef SUPPORT_PENGUINS
  5037.     if (quit_program == 1)
  5038.         /* Stop eating herring */
  5039.         write_comm_pipe_int (&drawing_pipe, -3, 1);
  5040. #endif
  5041.     return;
  5042.     }
  5043.  
  5044.     last_redraw_point++;
  5045.     if (lof_changed || !interlace_seen || last_redraw_point >= 2 || lof) {
  5046.     if (framecnt == 0)
  5047.         finish_drawing_frame ();
  5048.     count_frame ();
  5049.     last_redraw_point = 0;
  5050.     /* There may be reasons why we want to override count_frame()'s
  5051.      * decision. */
  5052.     if (inhibit_frame > 0)
  5053.         framecnt = 1;
  5054.     else {
  5055.         
  5056.     }
  5057.     if (framecnt == 0)
  5058.         init_drawing_frame ();
  5059.     }
  5060.     
  5061.     lof_changed = 0;
  5062.     interlace_seen = 0;
  5063.     COPJMP1(0);
  5064.     
  5065.     init_hardware_frame();
  5066. #ifdef HAVE_GETTIMEOFDAY
  5067.     {
  5068.     struct timeval tv;
  5069.     unsigned long int newtime;
  5070.     
  5071.     gettimeofday(&tv,NULL);    
  5072.     newtime = (tv.tv_sec-seconds_base) * 1000 + tv.tv_usec / 1000;
  5073.     
  5074.     if (!bogusframe) {    
  5075.         frametime += newtime - msecs;
  5076.         timeframes++;
  5077.     }
  5078.     msecs = newtime;
  5079.     bogusframe = 0;
  5080.     }
  5081. #endif
  5082.     if (ievent_alive > 0)
  5083.     ievent_alive--;
  5084.     CIA_vsync_handler();
  5085. }
  5086.  
  5087. static void hsync_handler(void)
  5088. {
  5089.     int lineno = next_lineno;
  5090.     int lineisdouble = 0;
  5091.     int line_was_doubled = 0;
  5092.     
  5093.     finish_decisions ();
  5094.     do_modulos ();
  5095.  
  5096.     if (framecnt == 0) {
  5097.     switch (nln_how) {
  5098.      case 0:
  5099.         linestate[lineno] = LINE_DECIDED;
  5100.         break;
  5101.      case 1:
  5102.         linestate[lineno] = LINE_DECIDED_DOUBLE;
  5103.         if (linestate[lineno+1] != LINE_REMEMBERED_AS_PREVIOUS)
  5104.         linestate[lineno+1] = LINE_AS_PREVIOUS;
  5105.         break;
  5106.      case 2:
  5107.         if (linestate[lineno-1] == LINE_UNDECIDED)
  5108.         linestate[lineno-1] = LINE_BORDER_NEXT;
  5109.         linestate[lineno] = LINE_DECIDED;
  5110.         break;
  5111.      case 3:
  5112.         linestate[lineno] = LINE_DECIDED;
  5113.         if (linestate[lineno+1] == LINE_UNDECIDED
  5114.         || linestate[lineno+1] == LINE_REMEMBERED_AS_PREVIOUS
  5115.         || linestate[lineno+1] == LINE_AS_PREVIOUS)
  5116.         linestate[lineno+1] = LINE_BORDER_PREV;
  5117.         break;
  5118.     }
  5119.     }
  5120.  
  5121.     eventtab[ev_hsync].evtime += cycles - eventtab[ev_hsync].oldcycles;
  5122.     eventtab[ev_hsync].oldcycles = cycles;
  5123.     CIA_hsync_handler();
  5124.     
  5125.     if (currprefs.produce_sound > 0) {
  5126.     int nr;
  5127.     /* Sound data is fetched at the beginning of each line */
  5128.     for (nr = 0; nr < 4; nr++) {
  5129.         struct audio_channel_data *cdp = audio_channel + nr;
  5130.         
  5131.         if (cdp->data_written == 2) {
  5132.         cdp->data_written = 0;
  5133.         cdp->nextdat = chipmem_bank.wget(cdp->pt);
  5134.         cdp->pt += 2;
  5135.         if (cdp->state == 2 || cdp->state == 3) {
  5136.             if (cdp->wlen == 1) {
  5137.             cdp->pt = cdp->lc;
  5138.             cdp->wlen = cdp->len;
  5139.             cdp->intreq2 = 1;
  5140.             } else
  5141.             cdp->wlen--;
  5142.         }
  5143.         }
  5144.     }
  5145.     }
  5146. #ifdef SUPPORT_PENGUINS
  5147.     if (framecnt == 0 && penguins_enabled_thisframe) {
  5148.     write_comm_pipe_int (&drawing_pipe, next_lineno, 0);
  5149.     }
  5150. #endif
  5151. #ifndef SMART_UPDATE
  5152.     {
  5153.     int i, where;
  5154.     /* l is the line that has been finished for drawing. */
  5155.     i = next_lineno - thisframe_y_adjust_real;
  5156.     if (i >= 0 && i < max_ypos_thisframe) {
  5157.         where = amiga2aspect_line_map[i+min_ypos_for_screen];
  5158.         if (where < gfxvidinfo.maxline && where != -1)
  5159.         pfield_draw_line (next_lineno, where, amiga2aspect_line_map[i+min_ypos_for_screen+1]);
  5160.     }
  5161.     }
  5162. #endif
  5163.     if (++vpos == (maxvpos + (lof != 0))) {
  5164.     vpos = 0;
  5165.     vsync_handler();
  5166.     }
  5167.  
  5168.     is_lastline = vpos + 1 == maxvpos + (lof != 0);
  5169.  
  5170.     if ((bplcon0 & 4) && currprefs.gfx_linedbl) {
  5171.     interlace_seen = 1, penguins_enabled_thisframe = 0;
  5172.     }
  5173.  
  5174.     if (framecnt == 0) {
  5175.     lineno = vpos;
  5176.     nln_how = 0;
  5177.     if (currprefs.gfx_linedbl) {
  5178.         lineno *= 2;
  5179.         nln_how = 1;
  5180.         if (bplcon0 & 4) {
  5181.         if (!lof) {
  5182.             lineno++;
  5183.             nln_how = 2;
  5184.         } else {
  5185.             nln_how = 3;
  5186.         }
  5187.         }
  5188.     }
  5189.     next_lineno = lineno;
  5190.     reset_decisions ();
  5191.     }
  5192.     if (uae_int_requested) {
  5193.     set_uae_int_flag ();
  5194.     INTREQ (0xA000);
  5195.     }
  5196. }
  5197.  
  5198. void customreset(void)
  5199. {
  5200.     int i, maxl;
  5201.     double native_lines_per_amiga_line;
  5202. #ifdef HAVE_GETTIMEOFDAY
  5203.     struct timeval tv;
  5204. #endif
  5205.  
  5206.     for (i = 0; i < sizeof current_colors.color_regs / sizeof *current_colors.color_regs; i++)
  5207.     current_colors.color_regs[i] = -1;
  5208.  
  5209. #ifdef FRAME_RATE_HACK
  5210.     did_reset = 1;
  5211.     vsyncmintime = read_processor_time() + vsynctime;
  5212. #endif
  5213.     inhibit_frame = 0;
  5214.     expamem_reset ();
  5215.     filesys_reset ();
  5216.     CIA_reset ();
  5217.     cycles = 0; 
  5218.     regs.spcflags &= SPCFLAG_BRK;
  5219.     
  5220.     lores_factor = currprefs.gfx_lores ? 1 : 2;
  5221.     lores_shift = currprefs.gfx_lores ? 0 : 1;
  5222.     sprite_width = currprefs.gfx_lores ? 16 : 32;
  5223.     
  5224.     vpos = 0;
  5225.     is_lastline = 0;
  5226.     lof = 0;
  5227.     max_diwstop = 0;
  5228.     
  5229.     if (needmousehack()) {
  5230. #if 1/* 0 ATB XXXXX */
  5231.         if (mousestate != follow_mouse) setfollow();
  5232. #else
  5233.         if (mousestate != dont_care_mouse) setdontcare();
  5234. #endif
  5235.     } else {
  5236.     mousestate = normal_mouse;
  5237.     }
  5238.     ievent_alive = 0;
  5239.  
  5240.     clx_sprmask = 0xFF;    
  5241.     clxdat = 0;
  5242.     
  5243.     memset(sprarmed, 0, sizeof sprarmed);
  5244.     nr_armed = 0;
  5245.     
  5246.     /*memset(blitcount, 0, sizeof(blitcount));  blitter debug */
  5247.     for (i = 0; i < (maxvpos+1)*2 + 1; i++) {
  5248.     linestate[i] = LINE_UNDECIDED;
  5249.     }
  5250.     xlinebuffer = gfxvidinfo.bufmem;
  5251.  
  5252.     dmacon = intena = 0;
  5253.     bltstate = BLT_done;
  5254.     copstate = COP_stop;
  5255.     diwstate = DIW_waiting_start;
  5256.     hdiwstate = DIW_waiting_start;
  5257.     copcon = 0;
  5258.     dskdmaen = 0;
  5259.     cycles = 0;
  5260.     
  5261.     memset(audio_channel, 0, sizeof audio_channel);
  5262.  
  5263.     bplcon4 = 0x11; /* Get AGA chipset into ECS compatibility mode */
  5264.     bplcon3 = 0xC00;
  5265.     for(i = 0; i < ev_max; i++) {
  5266.     eventtab[i].active = 0;
  5267.     eventtab[i].oldcycles = 0;
  5268.     }
  5269.     copper_active = 0;
  5270.     eventtab[ev_cia].handler = CIA_handler;
  5271.     eventtab[ev_copper].handler = currprefs.copper_pos < 0 ? do_copper : do_copper_cheat;
  5272.     eventtab[ev_hsync].handler = hsync_handler;
  5273.     eventtab[ev_hsync].evtime = maxhpos + cycles;
  5274.     eventtab[ev_hsync].active = 1;
  5275.  
  5276.     eventtab[ev_blitter].handler = blitter_handler;
  5277.     eventtab[ev_blitter].active = 0;
  5278.     eventtab[ev_diskblk].handler = diskblk_handler;
  5279.     eventtab[ev_diskblk].active = 0;
  5280.     eventtab[ev_diskindex].handler = diskindex_handler;
  5281.     eventtab[ev_diskindex].active = 0;
  5282. #ifndef DONT_WANT_SOUND
  5283.     eventtab[ev_aud0].handler = aud0_handler;
  5284.     eventtab[ev_aud0].active = 0;
  5285.     eventtab[ev_aud1].handler = aud1_handler;
  5286.     eventtab[ev_aud1].active = 0;
  5287.     eventtab[ev_aud2].handler = aud2_handler;
  5288.     eventtab[ev_aud2].active = 0;
  5289.     eventtab[ev_aud3].handler = aud3_handler;
  5290.     eventtab[ev_aud3].active = 0;
  5291.     if (sound_available && currprefs.produce_sound >= 2) {
  5292.     eventtab[ev_sample].active = 1;
  5293.     eventtab[ev_sample].evtime = sample_evtime;
  5294.     } else {
  5295.     eventtab[ev_sample].active = 0;
  5296.     }
  5297. #endif
  5298.     events_schedule ();
  5299.  
  5300.     if (native2amiga_line_map)
  5301.     free (native2amiga_line_map);
  5302.     if (amiga2aspect_line_map)
  5303.     free (amiga2aspect_line_map);
  5304.  
  5305.     /* At least for this array the +1 is necessary. */ 
  5306.     amiga2aspect_line_map = (int *)malloc (sizeof (int) * (maxvpos+1)*2 + 1);
  5307.     native2amiga_line_map = (int *)malloc (sizeof (int) * gfxvidinfo.maxline);
  5308.  
  5309.     if (currprefs.gfx_correct_aspect)
  5310.     native_lines_per_amiga_line = ((double)gfxvidinfo.maxline
  5311.                        * (currprefs.gfx_lores ? 320 : 640)
  5312.                        / (currprefs.gfx_linedbl ? 512 : 256)
  5313.                        / gfxvidinfo.maxlinetoscr);
  5314.     else
  5315.     native_lines_per_amiga_line = 1;
  5316.  
  5317.     maxl = (maxvpos+1) * (currprefs.gfx_linedbl ? 2 : 1);
  5318.     min_ypos_for_screen = minfirstline << (currprefs.gfx_linedbl ? 1 : 0);
  5319.     max_drawn_amiga_line = -1;
  5320.     for (i = 0; i < maxl; i++) {
  5321.     int v = (i - min_ypos_for_screen) * native_lines_per_amiga_line;
  5322.     if (v >= gfxvidinfo.maxline && max_drawn_amiga_line == -1)
  5323.         max_drawn_amiga_line = i-min_ypos_for_screen;
  5324.     if (i < min_ypos_for_screen || v >= gfxvidinfo.maxline)
  5325.         v = -1;
  5326.     amiga2aspect_line_map[i] = v;
  5327.     }
  5328.     if (currprefs.gfx_linedbl)
  5329.     max_drawn_amiga_line >>= 1;
  5330.  
  5331.     if (currprefs.gfx_ycenter && !(currprefs.gfx_correct_aspect)) {
  5332.     extra_y_adjust = (gfxvidinfo.maxline - (maxvpos << (currprefs.gfx_linedbl ? 1 : 0))) >> 1;
  5333.     if (extra_y_adjust < 0)
  5334.         extra_y_adjust = 0;
  5335.     }
  5336.  
  5337.     for (i = 0; i < gfxvidinfo.maxline; i++)
  5338.     native2amiga_line_map[i] = -1;
  5339.  
  5340.     if (native_lines_per_amiga_line < 1) {
  5341.     /* Must omit drawing some lines. */
  5342.     for (i = maxl-1; i > min_ypos_for_screen; i--) {
  5343.         if (amiga2aspect_line_map[i] == amiga2aspect_line_map[i-1]) {
  5344.         if (currprefs.gfx_linedbl && (i & 1) == 0  && amiga2aspect_line_map[i+1] != -1) {
  5345.             /* If only the first line of a line pair would be omitted,
  5346.              * omit the second one instead to avoid problems with line
  5347.              * doubling. */
  5348.             amiga2aspect_line_map[i] = amiga2aspect_line_map[i+1];
  5349.             amiga2aspect_line_map[i+1] = -1;
  5350.         } else
  5351.             amiga2aspect_line_map[i] = -1;
  5352.         }
  5353.     }
  5354.     }
  5355.  
  5356.     for (i = maxl-1; i >= min_ypos_for_screen; i--) {
  5357.     int j;
  5358.     if (amiga2aspect_line_map[i] == -1)
  5359.         continue;
  5360.     for (j = amiga2aspect_line_map[i]; j < gfxvidinfo.maxline && native2amiga_line_map[j] == -1; j++)
  5361.         native2amiga_line_map[j] = i >> (currprefs.gfx_linedbl ? 1 : 0);
  5362.     }
  5363.     
  5364.     if (line_drawn == 0)
  5365.     line_drawn = (char *)malloc (gfxvidinfo.maxline);
  5366.     if (row_map != 0)
  5367.     free (row_map);
  5368.     row_map = (char **)malloc (sizeof (char *) * (gfxvidinfo.maxline+1));
  5369.     init_row_map();
  5370.     init_hardware_frame ();
  5371.     init_drawing_frame ();
  5372.     last_redraw_point = 0;
  5373.     reset_decisions ();
  5374. #ifdef HAVE_GETTIMEOFDAY
  5375.     gettimeofday(&tv,NULL);
  5376.     seconds_base = tv.tv_sec;
  5377.     bogusframe = 1;
  5378. #endif
  5379. }
  5380.  
  5381. void dumpcustom(void)
  5382. {
  5383.     int i;
  5384.     fprintf(stderr, "DMACON: %x INTENA: %x INTREQ: %x VPOS: %x HPOS: %x\n", DMACONR(),
  5385.        intena, intreq, vpos, current_hpos());
  5386.     if (timeframes) { 
  5387.     fprintf(stderr, "Average frame time: %d ms [frames: %d time: %d]\n", 
  5388.            frametime/timeframes, timeframes, frametime);
  5389.     }
  5390.     /*for (i=0; i<256; i++) if (blitcount[i]) fprintf(stderr, "minterm %x = %d\n",i,blitcount[i]);  blitter debug */
  5391. }
  5392.  
  5393. int intlev(void)
  5394. {
  5395.     uae_u16 imask = intreq & intena;
  5396.     if (imask && (intena & 0x4000)){
  5397.     if (imask & 0x2000) return 6;
  5398.     if (imask & 0x1800) return 5;
  5399.     if (imask & 0x0780) return 4;
  5400.     if (imask & 0x0070) return 3;
  5401.     if (imask & 0x0008) return 2;
  5402.     if (imask & 0x0007) return 1;
  5403.     }
  5404.     return -1;
  5405. }
  5406.  
  5407. void custom_init(void)
  5408. {
  5409.     int num;
  5410.  
  5411. #ifdef OS_WITHOUT_MEMORY_MANAGEMENT
  5412.     for(num=0;num<2;++num) {
  5413.        sprite_positions[num] = malloc(max_sprite_draw * sizeof(struct sprite_draw));
  5414.        color_changes[num] = malloc(max_color_change * sizeof(struct color_change));
  5415.        if(!sprite_positions[num] || !color_changes[num]) {
  5416.              printf("Out of mem in %s %d!\n",__FILE__,__LINE__);
  5417.              abort();
  5418.        }
  5419.     }
  5420.     if(!(delay_changes = malloc(max_delay_change * sizeof(struct delay_change)))) {
  5421.        printf("Out of mem int %s %d!\n",__FILE__,__LINE__);
  5422.        abort();
  5423.     }
  5424. #endif
  5425.     
  5426.     if (needmousehack())
  5427.     setfollow();
  5428.     init_regchanges ();
  5429.     init_decisions ();
  5430.  
  5431.     /* For now, the AGA stuff is broken in the dual playfield case. We encode
  5432.      * sprites in dpf mode by ORing the pixel value with 0x80. To make dual
  5433.      * playfield rendering easy, the lookup tables contain are made linear for
  5434.      * values >= 128. That only works for OCS/ECS, though. */
  5435.     
  5436.     for (num = 0; num < 256; num++) {    
  5437.     int plane1 = (num & 1) | ((num >> 1) & 2) | ((num >> 2) & 4) | ((num >> 3) & 8);
  5438.     int plane2 = ((num >> 1) & 1) | ((num >> 2) & 2) | ((num >> 3) & 4) | ((num >> 4) & 8);
  5439.     dblpf_2nd1[num] = plane1 == 0 ? (plane2 == 0 ? 0 : 2) : 1;
  5440.     dblpf_2nd2[num] = plane2 == 0 ? (plane1 == 0 ? 0 : 1) : 2;
  5441.     if (plane2 > 0) plane2 += 8;
  5442.     dblpf_ind1[num] = num >= 128 ? num & 0x7F : (plane1 == 0 ? plane2 : plane1);
  5443.     dblpf_ind2[num] = num >= 128 ? num & 0x7F : (plane2 == 0 ? plane1 : plane2);
  5444.     
  5445.     lots_of_twos[num] = num == 0 ? 0 : 2;
  5446.     linear_map_256[num] = num;
  5447.     }
  5448.     build_blitfilltable();
  5449.     gen_pfield_tables();
  5450.     native2amiga_line_map = 0;
  5451.     amiga2aspect_line_map = 0;
  5452.     line_drawn = 0;
  5453.     row_map = 0;
  5454.  
  5455. #ifdef SUPPORT_PENGUINS
  5456.     init_comm_pipe (&drawing_pipe, 800, 5);
  5457.     uae_sem_init (&drawing_lock, 0, 0);
  5458.     start_penguin (drawing_penguin, 0, &our_penguin);
  5459.     /*atexit(kill_drawing_penguin);*/
  5460. #endif
  5461. }
  5462.  
  5463. /* Custom chip memory bank */
  5464.  
  5465. static uae_u32 custom_lget(uaecptr) REGPARAM;
  5466. static uae_u32 custom_wget(uaecptr) REGPARAM;
  5467. static uae_u32 custom_bget(uaecptr) REGPARAM;
  5468. static void  custom_lput(uaecptr, uae_u32) REGPARAM;
  5469. static void  custom_wput(uaecptr, uae_u32) REGPARAM;
  5470. static void  custom_bput(uaecptr, uae_u32) REGPARAM;
  5471.  
  5472. addrbank custom_bank = {
  5473.     custom_lget, custom_wget, custom_bget,
  5474.     custom_lput, custom_wput, custom_bput,
  5475.     default_xlate, default_check
  5476. };
  5477.  
  5478. uae_u32 REGPARAM2 custom_wget(uaecptr addr)
  5479. {
  5480.     switch(addr & 0x1FE) {
  5481.      case 0x002: return DMACONR();
  5482.      case 0x004: return VPOSR();
  5483.      case 0x006: return VHPOSR();
  5484.     
  5485.      case 0x008: return DSKDATR();
  5486.  
  5487.      case 0x00A: return JOY0DAT();
  5488.      case 0x00C: return JOY1DAT();
  5489.      case 0x00E: return CLXDAT();
  5490.      case 0x010: return ADKCONR();
  5491.  
  5492.      case 0x012: return POT0DAT();
  5493.      case 0x016: return POTGOR();
  5494.      case 0x018: return SERDATR();
  5495.      case 0x01A: return DSKBYTR();
  5496.      case 0x01C: return INTENAR();
  5497.      case 0x01E: return INTREQR();
  5498. #if AGA_CHIPSET == 1
  5499.      case 0x07C: return 0xF8;
  5500. #elif defined ECS_DENISE
  5501.      case 0x07C: return 0xFC;
  5502. #endif
  5503.      default:
  5504.     custom_wput(addr,0);
  5505.     return 0xffff;
  5506.     }
  5507. }
  5508.  
  5509. uae_u32 REGPARAM2 custom_bget(uaecptr addr)
  5510. {
  5511.     return custom_wget(addr & 0xfffe) >> (addr & 1 ? 0 : 8);
  5512. }
  5513.  
  5514. uae_u32 REGPARAM2 custom_lget(uaecptr addr)
  5515. {
  5516.     return ((uae_u32)custom_wget(addr & 0xfffe) << 16) | custom_wget((addr+2) & 0xfffe);
  5517. }
  5518.  
  5519. void REGPARAM2 custom_wput(uaecptr addr, uae_u32 value)
  5520. {
  5521.     addr &= 0x1FE;
  5522.     cregs[addr>>1] = value;
  5523.     switch(addr) {    
  5524.      case 0x020: DSKPTH(value); break;
  5525.      case 0x022: DSKPTL(value); break;
  5526.      case 0x024: DSKLEN(value); break;
  5527.      case 0x026: DSKDAT(value); break;
  5528.     
  5529.      case 0x02A: VPOSW(value); break;
  5530.      case 0x2E:  COPCON(value); break;
  5531.      case 0x030: SERDAT(value); break;
  5532.      case 0x032: SERPER(value); break;
  5533.  
  5534.      case 0x040: BLTCON0(value); break;
  5535.      case 0x042: BLTCON1(value); break;
  5536.     
  5537.      case 0x044: BLTAFWM(value); break;
  5538.      case 0x046: BLTALWM(value); break;
  5539.     
  5540.      case 0x050: BLTAPTH(value); break;
  5541.      case 0x052: BLTAPTL(value); break;
  5542.      case 0x04C: BLTBPTH(value); break;
  5543.      case 0x04E: BLTBPTL(value); break;
  5544.      case 0x048: BLTCPTH(value); break;
  5545.      case 0x04A: BLTCPTL(value); break;
  5546.      case 0x054: BLTDPTH(value); break;
  5547.      case 0x056: BLTDPTL(value); break;
  5548.     
  5549.      case 0x058: BLTSIZE(value); break;
  5550.     
  5551.      case 0x064: BLTAMOD(value); break;
  5552.      case 0x062: BLTBMOD(value); break;
  5553.      case 0x060: BLTCMOD(value); break;
  5554.      case 0x066: BLTDMOD(value); break;
  5555.     
  5556.      case 0x070: BLTCDAT(value); break;
  5557.      case 0x072: BLTBDAT(value); break;
  5558.      case 0x074: BLTADAT(value); break;
  5559.             
  5560.      case 0x07E: DSKSYNC(value); break;
  5561.  
  5562.      case 0x080: COP1LCH(value); break;
  5563.      case 0x082: COP1LCL(value); break;
  5564.      case 0x084: COP2LCH(value); break;
  5565.      case 0x086: COP2LCL(value); break;
  5566.     
  5567.      case 0x088: COPJMP1(value); break;
  5568.      case 0x08A: COPJMP2(value); break;
  5569.     
  5570.      case 0x08E: DIWSTRT(value); break;
  5571.      case 0x090: DIWSTOP(value); break;
  5572.      case 0x092: DDFSTRT(value); break;
  5573.      case 0x094: DDFSTOP(value); break;
  5574.     
  5575.      case 0x096: DMACON(value); break;
  5576.      case 0x098: CLXCON(value); break;
  5577.      case 0x09A: INTENA(value); break;
  5578.      case 0x09C: INTREQ(value); break;
  5579.      case 0x09E: ADKCON(value); break;
  5580.     
  5581.      case 0x0A0: AUDxLCH(0, value); break;
  5582.      case 0x0A2: AUDxLCL(0, value); break;
  5583.      case 0x0A4: AUDxLEN(0, value); break;
  5584.      case 0x0A6: AUDxPER(0, value); break;
  5585.      case 0x0A8: AUDxVOL(0, value); break;
  5586.      case 0x0AA: AUDxDAT(0, value); break;
  5587.     
  5588.      case 0x0B0: AUDxLCH(1, value); break;
  5589.      case 0x0B2: AUDxLCL(1, value); break;
  5590.      case 0x0B4: AUDxLEN(1, value); break;
  5591.      case 0x0B6: AUDxPER(1, value); break;
  5592.      case 0x0B8: AUDxVOL(1, value); break;
  5593.      case 0x0BA: AUDxDAT(1, value); break;
  5594.     
  5595.      case 0x0C0: AUDxLCH(2, value); break;
  5596.      case 0x0C2: AUDxLCL(2, value); break;
  5597.      case 0x0C4: AUDxLEN(2, value); break;
  5598.      case 0x0C6: AUDxPER(2, value); break;
  5599.      case 0x0C8: AUDxVOL(2, value); break;
  5600.      case 0x0CA: AUDxDAT(2, value); break;
  5601.     
  5602.      case 0x0D0: AUDxLCH(3, value); break;
  5603.      case 0x0D2: AUDxLCL(3, value); break;
  5604.      case 0x0D4: AUDxLEN(3, value); break;
  5605.      case 0x0D6: AUDxPER(3, value); break;
  5606.      case 0x0D8: AUDxVOL(3, value); break;
  5607.      case 0x0DA: AUDxDAT(3, value); break;
  5608.     
  5609.      case 0x0E0: BPLPTH(value, 0); break;
  5610.      case 0x0E2: BPLPTL(value, 0); break;
  5611.      case 0x0E4: BPLPTH(value, 1); break;
  5612.      case 0x0E6: BPLPTL(value, 1); break;
  5613.      case 0x0E8: BPLPTH(value, 2); break;
  5614.      case 0x0EA: BPLPTL(value, 2); break;
  5615.      case 0x0EC: BPLPTH(value, 3); break;
  5616.      case 0x0EE: BPLPTL(value, 3); break;
  5617.      case 0x0F0: BPLPTH(value, 4); break;
  5618.      case 0x0F2: BPLPTL(value, 4); break;
  5619.      case 0x0F4: BPLPTH(value, 5); break;
  5620.      case 0x0F6: BPLPTL(value, 5); break;
  5621.     
  5622.      case 0x100: BPLCON0(value); break;
  5623.      case 0x102: BPLCON1(value); break;
  5624.      case 0x104: BPLCON2(value); break;
  5625.      case 0x106: BPLCON3(value); break;
  5626.     
  5627.      case 0x108: BPL1MOD(value); break;
  5628.      case 0x10A: BPL2MOD(value); break;
  5629.  
  5630.      case 0x110: BPL1DAT(value); break;
  5631.      case 0x112: BPL2DAT(value); break;
  5632.      case 0x114: BPL3DAT(value); break;
  5633.      case 0x116: BPL4DAT(value); break;
  5634.      case 0x118: BPL5DAT(value); break;
  5635.      case 0x11A: BPL6DAT(value); break;
  5636.     
  5637.      case 0x180: case 0x182: case 0x184: case 0x186: case 0x188: case 0x18A:
  5638.      case 0x18C: case 0x18E: case 0x190: case 0x192: case 0x194: case 0x196:
  5639.      case 0x198: case 0x19A: case 0x19C: case 0x19E: case 0x1A0: case 0x1A2:
  5640.      case 0x1A4: case 0x1A6: case 0x1A8: case 0x1AA: case 0x1AC: case 0x1AE:
  5641.      case 0x1B0: case 0x1B2: case 0x1B4: case 0x1B6: case 0x1B8: case 0x1BA:
  5642.      case 0x1BC: case 0x1BE:
  5643.     COLOR(value & 0xFFF, (addr & 0x3E) / 2);
  5644.     break;
  5645.      case 0x120: case 0x124: case 0x128: case 0x12C:
  5646.      case 0x130: case 0x134: case 0x138: case 0x13C:
  5647.     SPRxPTH(value, (addr - 0x120) / 4);
  5648.     break;
  5649.      case 0x122: case 0x126: case 0x12A: case 0x12E:
  5650.      case 0x132: case 0x136: case 0x13A: case 0x13E:
  5651.     SPRxPTL(value, (addr - 0x122) / 4);
  5652.     break;
  5653.      case 0x140: case 0x148: case 0x150: case 0x158:
  5654.      case 0x160: case 0x168: case 0x170: case 0x178:
  5655.     SPRxPOS(value, (addr - 0x140) / 8);
  5656.     break;
  5657.      case 0x142: case 0x14A: case 0x152: case 0x15A:
  5658.      case 0x162: case 0x16A: case 0x172: case 0x17A:
  5659.     SPRxCTL(value, (addr - 0x142) / 8);
  5660.     break;
  5661.      case 0x144: case 0x14C: case 0x154: case 0x15C:
  5662.      case 0x164: case 0x16C: case 0x174: case 0x17C:
  5663.     SPRxDATA(value, (addr - 0x144) / 8);
  5664.     break;
  5665.      case 0x146: case 0x14E: case 0x156: case 0x15E:
  5666.      case 0x166: case 0x16E: case 0x176: case 0x17E:
  5667.     SPRxDATB(value, (addr - 0x146) / 8);
  5668.     break;
  5669.     
  5670.      case 0x36: JOYTEST(value); break;
  5671. #if defined(ECS_AGNUS) || (AGA_CHIPSET == 1)
  5672.      case 0x5A: BLTCON0L(value); break;
  5673.      case 0x5C: BLTSIZV(value); break;
  5674.      case 0x5E: BLTSIZH(value); break;
  5675. #endif
  5676. #if AGA_CHIPSET == 1
  5677.      case 0x10C: BPLCON4(value); break;
  5678.      case 0x1FC: fmode = value; break;
  5679. #endif
  5680.     }
  5681. }
  5682.  
  5683. void REGPARAM2 custom_bput(uaecptr addr, uae_u32 value)
  5684. {
  5685.     static int warned = 0;
  5686.     /* Is this correct now? (There are people who bput things to the upper byte of AUDxVOL). */
  5687.     uae_u16 rval = (value << 8) | (value & 0xFF);
  5688.     custom_wput(addr, rval);
  5689.     if (!warned)
  5690.     write_log ("Byte put to custom register.\n"), warned++;
  5691. }
  5692.  
  5693. void REGPARAM2 custom_lput(uaecptr addr, uae_u32 value)
  5694. {
  5695.     custom_wput(addr & 0xfffe, value >> 16);
  5696.     custom_wput((addr+2) & 0xfffe, (uae_u16)value);
  5697. }
  5698.